agent-loft 0.2.45 → 0.2.47

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -64,11 +64,11 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
64
64
  - **设置都在网页上**,按用途分组:**我的**(账号和密码、飞书绑定、登录设备、通知、记忆、技能、用量,每个人都有);**Agent**(运行环境、各 agent 的默认模型和思考程度、可选模型、Codex 沙箱、额度查询;工作目录、会话闲置过期、授权卡超时和 Claude 的「总是允许」名单;「/」命令);**连接**(飞书机器人、配对批准、指令面板同步;远程控制;服务器);**管理**(用户、所有人的登录设备;服务端版本和升级、重启、局域网访问和端口)。改了没保存就切页或关掉设置会先提醒。
65
65
  - **多用户**(信任型):管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知,设置只有管理员能改,见下面「安全」。
66
66
  - **聊天模式 / 工作模式**:右上角「更多」里的「聊天模式」,或者发 `/chat`、`/work`,同一条对话随时切换、上下文接着。聊天模式换成精简的系统提示,只留联网搜索,不加载技能、MCP、插件,不执行命令、不读写本机文件(文本附件的内容直接放进消息),每轮的固定开销小得多:实测一句话 Claude 约 1.6 万 → 2 千 token,Codex 约 2 万 → 1.2 万(Codex 的基础指令改不了)。适合日常聊天、查资料;要动手干活时切回工作模式。切换后第一轮要重建提示缓存,会贵一些;在工作模式里读过的大段内容还留在历史里。
67
- - **记忆**:像 ChatGPT 的记忆,设置 → 记忆。「关于我」加上一条条记住的事,每次对话都带上;agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条(回复里会说),记错了用 `forget` 删。**自动整理**:把上次整理之后新说的话交给模型(不留会话记录的一次性调用),补充、更新或删掉过时的记忆,用户自己加的条目它不动。什么时候整理每个人自己定:每天一次(默认凌晨 4 点,把当天的对话合起来一次整理,最省)/每段对话聊完后(停多久可选,改了什么会在对话里说一声)/只在点「现在整理」时/不整理;整理哪些对话也能选:全部/只整理聊天模式的/只整理工作模式的;用哪个 agent 的哪个模型也能选,默认 Claude Haiku,没有 Claude 就用 Codex 的默认模型、思考程度 low。**参考以前的聊天**:agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话(关键词搜索,只有你自己的、没被删掉的对话;第一次用时会把已有对话收录进来)。两项都能在设置里单独关。每个用户一份,Claude 和 Codex、Web 和飞书共用。只用在有主人的对话里:你的 Web 对话,以及绑定了飞书账号后和机器人的私聊;飞书群聊不用。别人(包括管理员)看不到你的记忆,管理员只能清空它;删用户时记忆一起删,不转给管理员。
67
+ - **记忆**:像 ChatGPT 的记忆,设置 → 记忆(默认关)。「关于我」加上一条条记住的事,每次对话都带上;agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条(回复里会说),记错了用 `forget` 删。**自动整理**:把上次整理之后新说的话交给模型(不留会话记录的一次性调用),补充、更新或删掉过时的记忆,用户自己加的条目它不动。什么时候整理每个人自己定:每天一次(默认凌晨 2 点,把当天的对话合起来一次整理,最省)/每段对话聊完后(停多久可选,改了什么会在对话里说一声)/只在点「现在整理」时/不整理;整理哪些对话也能选:全部/只整理聊天模式的/只整理工作模式的;用哪个 agent 的哪个模型也能选,默认 Claude Haiku,没有 Claude 就用 Codex 的默认模型、思考程度 low。**参考以前的聊天**:agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话(关键词搜索,只有你自己的、没被删掉的对话;第一次用时会把已有对话收录进来)。两项都能在设置里单独关。每个用户一份,Claude 和 Codex、Web 和飞书共用。只用在有主人的对话里:你的 Web 对话,以及绑定了飞书账号后和机器人的私聊;飞书群聊不用。别人(包括管理员)看不到你的记忆,管理员只能清空它;删用户时记忆一起删,不转给管理员。
68
68
  - **定时任务**:像 ChatGPT 的 Tasks,侧栏「最近」上面的「定时任务」。到点把一段提示词交给 agent,结果发回对话:一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron,按服务端时区,两次至少隔 15 分钟。**有需要才提醒**(默认):agent 自己判断这次有没有要告诉你的事(比如「有新版本才告诉我」),没有就在回复第一行写 `[[静默]]`,推送、飞书都不发,对话里折叠成一行;没写暗号一律照常提醒。结果发到**专用对话**(任务自己的一条对话,第一次运行时新建、之后续用,可选聊天 / 工作模式和目录),或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」:agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理,新建、修改、删除都会先弹授权卡让你确认(只有暂停不用;没有「总是允许」),任务自己运行的那一轮里不能再建、改、删任务。按人隔离:每人只看得到、改得了自己的任务(最多 30 个),删用户时一起删;到点再核对一次对话还是不是他的,对话被删或换了主人就暂停任务。到点对话在忙(正在回复或挂着授权)就等它,最多 30 分钟;服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话,飞书群聊里没有。
69
69
  - **技能(skills)**:设置 → 技能。技能就是 Claude Code / Codex 用的那种 SKILL.md(可以带脚本和资料),由 agent-loft 按人管理,两个 agent 都能用。**来源**:在页面上写、上传技能包(`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹),或者在对话里让 agent「把刚才的做法存成技能」(agent 用 `create_skill` / `update_skill`,先弹授权卡)。每人管自己的,不做分享和技能广场(以前从别人那装过的照常能用,可以卸载)。**使用**:工作模式下 agent 遇到对得上的事自己用;在输入框或定时任务的「要做的事」里打 `@` 选技能,点名这次用哪个(聊天模式下会把技能内容直接附上);飞书里发 `/skills` 看能 @ 哪些。**变量**:技能可以声明要用的环境变量(接口地址、密钥),每个人填自己的值,只注入自己的会话;密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量,agent 看不到值,只能用 `skill_request` 工具让 agent-loft 代发请求(在地址、请求头、请求体里写 `{{变量名}}`),只发往你确认过的地址、不跟随跳转、响应里出现的值会被抹掉;作者后来改了地址,要你再确认一次才放行。**机器上原有的技能**(`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的)只给管理员:成员的会话里看不到、调不了(Claude 用技能白名单,`/技能名` 也会被拦下;Codex 关掉它自己的技能清单),管理员在「设置 → 技能 → 本机技能」里能看到。
70
70
  - **远程控制**:侧栏「定时任务」下面的「远程控制」,直接操作这台机器的**桌面**和**终端**,上面一键切换;切回对话时连接留在后台(侧栏入口上亮个小绿点),再进来接着用。这台机器没有图形桌面(服务器、NAS)时只有终端。
71
- - 桌面:走 VNC 协议,网页里用 noVNC 显示,鼠标、键盘、剪贴板都能用,进来时不自动连、点「连接桌面」才连,工具栏上选画质:流畅 / 标准(默认)/ 高清由服务端把画面缩小到长边 1280 / 1920 / 2560、只把变了的地方压成 JPEG 发过来(macOS 屏幕共享只给无损的 ZRLE,5K 屏一整屏 30MB,原样转发隔着公网几秒一帧),原画是原样转发、只适合局域网;可以缩放到窗口或按原始大小看、全屏(手机上也能,iPhone 上是铺满页面)、「只看不控制」、发送 Ctrl+Alt+Del 之类的组合键。手机上有两种手势(右上角切换,「?」看说明):**触控板模式**(默认)屏幕上有个指针,单指滑动移动、轻点单击、双指轻点右键、长按后拖动是按住左键拖、双指滑动滚动;**触摸模式**点哪就点哪。两种模式都能双指捏合在本地放大画面(放大后小按钮也点得准,右下角「还原」),画面下面一排 Esc / Tab / Ctrl / Alt / Win / 方向键,Ctrl、Alt、Win 点一下会粘住,带给下一个按键或点击;键盘按钮弹出软键盘打字,中文输入法也能用。Linux 上 agent-loft 在有人连时用 x11vnc 共享当前的桌面(Xorg 会话;只听 127.0.0.1、随机端口、每次随机密码,需要 `sudo apt install x11vnc`),没人连着 30 分钟后停掉;macOS 上在 设置 → 远程控制 里改用「已有的 VNC 服务」,接系统自带的屏幕共享:填 VNC 密码,或者屏幕共享没开 VNC 密码时填 Mac 的用户名和登录密码(苹果认证,由服务端登录)。
71
+ - 桌面:走 VNC 协议,网页里用 noVNC 显示,鼠标、键盘、剪贴板都能用,进来时不自动连、点「连接桌面」才连,工具栏上选画质:流畅 / 标准(默认)/ 高清由服务端把画面缩小到长边 1280 / 1920 / 2560、只把变了的地方压成 JPEG 发过来(macOS 屏幕共享只给无损的 ZRLE,5K 屏一整屏 30MB,原样转发隔着公网几秒一帧),原画是原样转发、只适合局域网;远程那边接了几块屏时可以只看其中一块(按系统里的显示器名称选,服务端只截那块再缩,比几块屏拼在一起缩小清楚得多;macOS 的各块屏位置要从屏幕共享发来的画面里学,第一次连上要几秒,原画下不能选);可以缩放到窗口或按原始大小看、全屏(手机上也能,iPhone 上是铺满页面)、「只看不控制」、发送 Ctrl+Alt+Del 之类的组合键。手机上有两种手势(右上角切换,「?」看说明):**触控板模式**(默认)屏幕上有个指针,单指滑动移动、轻点单击、双指轻点右键、长按后拖动是按住左键拖、双指滑动滚动;**触摸模式**点哪就点哪。两种模式都能双指捏合在本地放大画面(放大后小按钮也点得准,右下角「还原」),画面下面一排 Esc / Tab / Ctrl / Alt / Win / 方向键,Ctrl、Alt、Win 点一下会粘住,带给下一个按键或点击;键盘按钮弹出软键盘打字,中文输入法也能用。Linux 上 agent-loft 在有人连时用 x11vnc 共享当前的桌面(Xorg 会话;只听 127.0.0.1、随机端口、每次随机密码,需要 `sudo apt install x11vnc`),没人连着 30 分钟后停掉;macOS 上在 设置 → 远程控制 里改用「已有的 VNC 服务」,接系统自带的屏幕共享:填 VNC 密码,或者屏幕共享没开 VNC 密码时填 Mac 的用户名和登录密码(苹果认证,由服务端登录)。
72
72
  - 终端:新终端开在当前对话的工作目录里,可以开多个标签;`Ctrl+Shift+C` / `Ctrl+Shift+V` 复制粘贴。`` Ctrl+` `` 在对话下面拉出终端面板(高度可拖动),面板和远程控制里的是同一批终端。关掉页面、手机切到后台、断线都不结束 shell,重新打开时接着用、补上错过的输出,别的设备上也能接上;没有页面连着超过 30 分钟(设置里可改)才结束,点标签上的 × 立即结束。依赖可选的原生模块 `node-pty`:Linux 上安装时要现场编译(需要 `make`、`g++`、`python3`),没装好时终端用不了,其他功能照常。手机上单指上下滑翻看历史(在 less、vim 里是翻页),长按选中文字、接着拖动扩大选区,再点「复制」;终端下面多一排 Esc / Tab / Ctrl / Alt / 方向键 / Home / End / PgUp / PgDn / 粘贴。iOS 上软键盘弹出来时这排键会垫到键盘上面。
73
73
  - 管理员能用;成员要管理员在 设置 → 用户 里单独「开通远程控制」。终端、桌面在 设置 → 远程控制 里各有总开关。
74
74
  - **飞书账号绑定**:设置 → 账号 → 飞书账号 →「生成绑定码」,再在飞书私聊机器人发 `/bind 绑定码`(10 分钟内有效,群里发不算)。绑定后这个私聊就是你的个人会话:用你的记忆,`/sessions` 只列你的会话,`/web` 只能接上你自己的 Web 会话,管理员在 Web 上也看不到它。必须本人在两边各操作一次,管理员不能替人绑定(只能解除),否则就能借飞书读到别人的记忆。
@@ -103,7 +103,7 @@ agent-loft service install # 注册为开机自启服务(systemd / laun
103
103
  - 菜单栏图标:悬停看各服务器的 Claude / Codex 额度、待处理和运行中的会话;双击打开主窗口。同一个账号的额度只查一次。(Windows 上点托盘图标弹出;Linux 上在托盘菜单里点「额度和待处理」。)
104
104
  - 菜单栏图标可以换成额度条:Claude、Codex 各是一只像素小宠物,看样子就知道是谁,身子是 5 小时额度,下面一条是周额度。桌面端设置 → 额度显示 →「菜单栏显示额度」,选所有服务器合起来(取最高),或者按服务器分别选 Claude / Codex(图标上不写服务器名);都不选就只显示图标。「额度条显示」选实心表示剩余额度(默认,像电池)还是已用额度。只有 macOS 有,Windows / Linux 的托盘图标太小放不下。
105
105
  - 支持前面挡着 Cloudflare Access 的服务器:验证页直接在窗口里完成,过期会提醒;也可以配 Service Token 免验证。
106
- - 首次打开可以选「这台 Mac 也作为服务端」:一键在终端里安装 agent-loft(没有 Node.js 会先用 Homebrew 装)并开机自启,装好自动连上。Linux 上一样(需要先装好 Node.js 22+,开机自启用 systemd 用户服务);Windows 上服务端还没有开机自启,可以在 WSL 里装,桌面端会自动检测到 `127.0.0.1` 上的它。防休眠:本机有会话在跑时不休眠;另有永不休眠、定时休眠(设休眠时段,时段外不休眠,时段内本机没有会话在跑、屏幕锁上后让 Mac 睡下去)和合盖不休眠(macOS,要管理员密码)。
106
+ - 首次打开可以选「这台 Mac 也作为服务端」:一键在终端里安装 agent-loft(没有 Node.js 会先用 Homebrew 装)并开机自启,装好自动连上;设置里可以改成「只在桌面端运行时运行」(不开机自启,打开桌面端时启动、退出时停止)。Linux 上一样(需要先装好 Node.js 22+,开机自启用 systemd 用户服务);Windows 上服务端还没有开机自启,可以在 WSL 里装,桌面端会自动检测到 `127.0.0.1` 上的它。防休眠:本机有会话在跑时不休眠;另有永不休眠、定时休眠(设休眠时段,时段外不休眠,时段内本机没有会话在跑、屏幕锁上后让 Mac 睡下去)和合盖不休眠(macOS,第一次开关要输管理员密码,之后不用;开着时闲置也不睡,定时休眠到点会临时关掉它让 Mac 睡下去,醒来再打开)。
107
107
  - 顶栏「更多」→「总量汇总」:把所有已添加服务器的用量加在一起看,按日 / 月 / 年统计 token 和金额,和网页设置 → 用量一样有柱状图和按 agent、模型、用户的分项,另外多一栏按服务器。不在线、没登录或服务端太旧的服务器不计入,页面上会注明。
108
108
  - 设置(`⌘,`)的服务器列表里展开某台服务器,能看它的 Agent 环境和版本,有新版本时点「升级服务端」;桌面端自己的更新在同一页的「更新」里点「更新并重启」。
109
109
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "agent-loft",
3
- "version": "0.2.45",
3
+ "version": "0.2.47",
4
4
  "type": "module",
5
5
  "description": "多个 agent 的工作台:把本机 Claude Code / Codex 放到一处统一管理,用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
6
6
  "keywords": [
@@ -1,11 +1,13 @@
1
1
  // 远程控制的接口:GET /api/remote 告诉页面终端、桌面各自能不能用;
2
2
  // POST /api/desktop/session 准备好桌面(必要时起 x11vnc),把这次的 VNC 密码给页面;
3
+ // GET /api/desktop/screens 有哪几块屏(页面选只看哪块);
3
4
  // /ws/desktop 把页面(noVNC)的 WebSocket 原样转到 VNC 服务的 TCP 端口,和 websockify 一样。
4
5
  import net from "node:net";
5
6
  import type { IncomingMessage, ServerResponse } from "node:http";
6
7
  import type { Duplex } from "node:stream";
7
8
  import type { WebSocket, WebSocketServer } from "ws";
8
9
  import { canUseDesktop, desktopAvailability, desktopTarget, desktopViewer, type DesktopTarget } from "../../core/desktop.js";
10
+ import { desktopScreens, screenSource } from "../../core/desktop-screens.js";
9
11
  import { canUseRemote, isAdmin, type User } from "../../core/users.js";
10
12
  import { config } from "../../core/config.js";
11
13
  import { ByteReader, serveNoAuth, vncLogin } from "../../core/vnc-auth.js";
@@ -52,6 +54,11 @@ export async function handleDesktopApi(req: IncomingMessage, res: ServerResponse
52
54
  sendJson(res, 200, { password: target.username ? "" : target.password, source: config().remote.desktopSource });
53
55
  return true;
54
56
  }
57
+ if (p === "/api/desktop/screens" && method === "GET") {
58
+ if (!canUseDesktop(user)) throw new HttpError(403, "你没有使用远程桌面的权限");
59
+ sendJson(res, 200, desktopScreens());
60
+ return true;
61
+ }
55
62
  return false;
56
63
  }
57
64
 
@@ -100,7 +107,8 @@ function reject(socket: Duplex, status: string): void {
100
107
 
101
108
  /**
102
109
  * /ws/desktop 的握手:user 已经由调用方核对过登录和 Origin。
103
- * ?q= 是画质:smooth / standard / high 由服务端缩小、压成 JPEG 再发(vnc-transcode.ts);original 或不带是原样转发
110
+ * ?q= 是画质:smooth / standard / high 由服务端缩小、压成 JPEG 再发(vnc-transcode.ts);original 或不带是原样转发。
111
+ * ?screen= 只看第几块屏(从 1 数,按 /api/desktop/screens 的顺序),只在转码时管用
104
112
  */
105
113
  export function upgradeDesktop(wss: WebSocketServer, req: IncomingMessage, socket: Duplex, head: Buffer, user: User, token: string, url: URL): void {
106
114
  if (!canUseDesktop(user)) return reject(socket, "403 Forbidden");
@@ -119,8 +127,9 @@ export function upgradeDesktop(wss: WebSocketServer, req: IncomingMessage, socke
119
127
  if (socket.destroyed) return void tcp.destroy();
120
128
  socket.off("error", onError);
121
129
  const q = url.searchParams.get("q");
130
+ const screen = Math.max(0, Math.floor(Number(url.searchParams.get("screen")) || 0));
122
131
  wss.handleUpgrade(req, socket, head, (ws) => {
123
- if (isDesktopQuality(q)) return void transcodeSession(ws, tcp, token, target, q);
132
+ if (isDesktopQuality(q)) return void transcodeSession(ws, tcp, token, target, q, screen);
124
133
  if (!target.username) return bridge(ws, tcp, token);
125
134
  void loginThenBridge(ws, tcp, token, target.username, target.password);
126
135
  });
@@ -177,7 +186,7 @@ function isLoopback(host: string): boolean {
177
186
  }
178
187
 
179
188
  /** 转码:服务端连 VNC、缩小画面压成 JPEG 发给页面 */
180
- async function transcodeSession(ws: WebSocket, tcp: net.Socket, token: string, target: DesktopTarget, quality: DesktopQuality): Promise<void> {
189
+ async function transcodeSession(ws: WebSocket, tcp: net.Socket, token: string, target: DesktopTarget, quality: DesktopQuality, screen: number): Promise<void> {
181
190
  // 握手前那个「回 502」的已经用不上了(socket 交给 WebSocket 了)
182
191
  tcp.removeAllListeners("error");
183
192
  tcp.on("error", () => tcp.destroy());
@@ -194,6 +203,9 @@ async function transcodeSession(ws: WebSocket, tcp: net.Socket, token: string, t
194
203
  const client: DesktopClient = { ws, tcp, token, alive: true };
195
204
  clients.add(client);
196
205
  desktopViewer(1);
206
+ const local = isLoopback(target.host);
207
+ // 读系统里的屏幕要一会儿(osascript):先接住两头的数据,别丢
208
+ const screens = screenSource(`${target.host}:${target.port}`, { local, display: config().remote.desktopSource === "auto" ? desktopAvailability().display : undefined });
197
209
  const fromVnc = new ByteReader();
198
210
  const fromPage = new ByteReader();
199
211
  tcp.on("data", (d: Buffer) => fromVnc.push(d));
@@ -214,7 +226,9 @@ async function transcodeSession(ws: WebSocket, tcp: net.Socket, token: string, t
214
226
  page: { reader: fromPage, write: (b) => void (ws.readyState === ws.OPEN && ws.send(b, { binary: true })), backlog: () => ws.bufferedAmount },
215
227
  creds: { username: target.username, password: target.password },
216
228
  quality,
217
- local: isLoopback(target.host),
229
+ local,
230
+ screen,
231
+ screens: await screens,
218
232
  onReady: () => clearTimeout(timer),
219
233
  });
220
234
  } catch (err) {
@@ -0,0 +1,121 @@
1
+ // 远程桌面的多块屏:每块屏在 VNC 画面里的哪里、叫什么,页面可以只看其中一块(vnc-transcode.ts 按它裁剪)。
2
+ // - macOS 屏幕共享:画面是几块屏按像素拼起来的,可每块屏的位置和系统里的屏幕坐标对不上
3
+ // (实测:竖直方向的偏移按点算、没乘 2 倍),只能从它发来的画面里学 —— 不增量地要整个画面时,它一次发一整块屏。
4
+ // 名字在本机时从系统里读(NSScreen),按像素大小、从左到右的顺序对上。
5
+ // - Linux 上自己起的 x11vnc:xrandr 直接给出每块屏的位置和接口名(DP-1 之类)。
6
+ // - 别的 VNC 服务:不知道,只能看整个画面。
7
+ // 学到的记在内存里,下次连上(画面大小没变)直接用。
8
+ import { execFile } from "node:child_process";
9
+ import type { Rect, ScreenSource } from "./vnc-transcode.js";
10
+
11
+ export type Screen = Rect & { name: string };
12
+
13
+ /** sig:学的时候系统里的屏幕(本机 macOS),变了就作废 */
14
+ type Layout = { key: string; sig: string; w: number; h: number; screens: Screen[] };
15
+
16
+ /** 知道的各块屏(按从左到右排) */
17
+ let known: Layout | null = null;
18
+
19
+ /** 页面要的:有哪几块屏(只给名字)。刚连上时 macOS 的可能还在学,页面过一会儿再问 */
20
+ export function desktopScreens(): { screens: { name: string }[] } {
21
+ return { screens: known?.screens.map((s) => ({ name: s.name })) ?? [] };
22
+ }
23
+
24
+ const byPosition = (a: Rect, b: Rect) => a.x - b.x || a.y - b.y;
25
+ const same = (a: Rect, b: Rect) => a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
26
+ const overlap = (a: Rect, b: Rect) => a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
27
+
28
+ /** 系统里的一块屏:名字、像素大小、位置(点,左下角为原点) */
29
+ export type SystemScreen = { name: string; w: number; h: number; x: number; y: number };
30
+
31
+ /** 本机 macOS 的各块屏 */
32
+ function macScreens(): Promise<SystemScreen[] | null> {
33
+ const script = `ObjC.import("AppKit");
34
+ const s = $.NSScreen.screens, out = [];
35
+ for (let i = 0; i < s.count; i++) {
36
+ const x = s.objectAtIndex(i), f = x.frame, k = x.backingScaleFactor;
37
+ out.push({ name: x.localizedName.js, w: Math.round(f.size.width * k), h: Math.round(f.size.height * k), x: f.origin.x, y: f.origin.y });
38
+ }
39
+ JSON.stringify(out);`;
40
+ return new Promise((resolve) => {
41
+ execFile("osascript", ["-l", "JavaScript", "-e", script], { timeout: 5000 }, (err, stdout) => {
42
+ if (err) return resolve(null);
43
+ try {
44
+ resolve(JSON.parse(stdout) as SystemScreen[]);
45
+ } catch {
46
+ resolve(null);
47
+ }
48
+ });
49
+ });
50
+ }
51
+
52
+ /** 学到的各块屏起上名字:和系统里的按像素大小对上,一样大的按从左到右的顺序;对不上的叫「屏幕 N」 */
53
+ export function nameScreens(rects: Rect[], system: SystemScreen[] | null): Screen[] {
54
+ const left = [...(system ?? [])].sort((a, b) => a.x - b.x || b.y - a.y);
55
+ return [...rects].sort(byPosition).map((r, i) => {
56
+ const k = left.findIndex((s) => s.w === r.w && s.h === r.h);
57
+ const name = k >= 0 ? left.splice(k, 1)[0]!.name : `屏幕 ${i + 1}`;
58
+ return { ...r, name };
59
+ });
60
+ }
61
+
62
+ /** xrandr --current 的输出 → 各块屏和整个画面的大小 */
63
+ export function parseXrandr(text: string): { w: number; h: number; screens: Screen[] } | null {
64
+ const size = /current (\d+) x (\d+)/.exec(text);
65
+ if (!size) return null;
66
+ const screens: Screen[] = [];
67
+ for (const m of text.matchAll(/^(\S+) connected (?:primary )?(\d+)x(\d+)\+(\d+)\+(\d+)/gm)) {
68
+ screens.push({ name: m[1]!, w: Number(m[2]), h: Number(m[3]), x: Number(m[4]), y: Number(m[5]) });
69
+ }
70
+ return { w: Number(size[1]), h: Number(size[2]), screens: screens.sort(byPosition) };
71
+ }
72
+
73
+ function xrandr(display: string): Promise<string | null> {
74
+ return new Promise((resolve) => {
75
+ execFile("xrandr", ["--current"], { timeout: 5000, env: { ...process.env, DISPLAY: display } }, (err, stdout) => resolve(err ? null : stdout));
76
+ });
77
+ }
78
+
79
+ /**
80
+ * 一次转码会话用的:key 区分不同的 VNC 服务。
81
+ * local:VNC 服务在本机(macOS 上能读到屏幕名字);display:x11vnc 共享的 X 显示
82
+ */
83
+ export async function screenSource(key: string, opts: { local: boolean; display?: string }): Promise<ScreenSource> {
84
+ if (known?.key !== key) known = null;
85
+ if (opts.display) {
86
+ const parsed = parseXrandr((await xrandr(opts.display)) ?? "");
87
+ known = parsed?.screens.length ? { key, sig: "", ...parsed } : null;
88
+ }
89
+ const system = opts.local && process.platform === "darwin" ? await macScreens() : null;
90
+ const sig = JSON.stringify(system);
91
+ // 系统里的屏幕换了(插拔、挪了位置、改了分辨率):之前学的作废
92
+ if (system && known?.sig !== sig) known = null;
93
+
94
+ /** 这次会话学到的 */
95
+ let seen: Rect[] = [];
96
+ let repeated = false;
97
+ return {
98
+ get: (w, h) => (known && known.w === w && known.h === h ? known.screens : null),
99
+ learn(w, h, rects) {
100
+ for (const r of rects) {
101
+ if (seen.some((s) => same(s, r))) {
102
+ repeated = true;
103
+ continue;
104
+ }
105
+ // 和学过的重叠:之前那块不对(摆法变了),换掉
106
+ seen = seen.filter((s) => !overlap(s, r));
107
+ seen.push(r);
108
+ }
109
+ // 学全了:拼起来正好是整个画面;知道有几块屏时数目对上,不知道时转了一圈又发回第一块
110
+ const covers =
111
+ seen.length > 0 &&
112
+ Math.min(...seen.map((s) => s.x)) === 0 &&
113
+ Math.min(...seen.map((s) => s.y)) === 0 &&
114
+ Math.max(...seen.map((s) => s.x + s.w)) === w &&
115
+ Math.max(...seen.map((s) => s.y + s.h)) === h;
116
+ const done = covers && (system ? seen.length === system.length : repeated);
117
+ if (done) known = { key, sig, w, h, screens: nameScreens(seen, system) };
118
+ return done;
119
+ },
120
+ };
121
+ }
@@ -58,7 +58,7 @@ export type CurateSettings = {
58
58
  model: string;
59
59
  };
60
60
 
61
- export const DEFAULT_CURATE: CurateSettings = { when: "daily", scope: "all", idleMinutes: 30, dailyHour: 4, agent: "auto", model: "" };
61
+ export const DEFAULT_CURATE: CurateSettings = { when: "daily", scope: "all", idleMinutes: 30, dailyHour: 2, agent: "auto", model: "" };
62
62
 
63
63
  function cleanCurate(raw: Partial<CurateSettings> | undefined, base: CurateSettings): CurateSettings {
64
64
  const r = raw ?? {};
@@ -96,7 +96,25 @@ function fileOf(userId: string): string {
96
96
  }
97
97
 
98
98
  function empty(): UserMemory {
99
- return { enabled: true, about: "", items: [], curate: { ...DEFAULT_CURATE }, chatHistory: true };
99
+ return { enabled: false, about: "", items: [], curate: { ...DEFAULT_CURATE }, chatHistory: true };
100
+ }
101
+
102
+ /**
103
+ * 记忆从默认开改成默认关(0.2.46):升级前就有、但还没写过记忆文件的用户,补一份开着的,
104
+ * 让老实例里的人保持原样。只跑一次,跑过留个标记;新装的第一次启动时还没有用户,什么都不补。
105
+ */
106
+ export function migrateMemoryDefault(userIds: string[]): void {
107
+ const marker = path.join(memoryDir, ".default-off-migrated");
108
+ if (fs.existsSync(marker)) return;
109
+ fs.mkdirSync(memoryDir, { recursive: true, mode: 0o700 });
110
+ let n = 0;
111
+ for (const id of userIds) {
112
+ if (fs.existsSync(fileOf(id))) continue;
113
+ write(id, { ...empty(), enabled: true });
114
+ n++;
115
+ }
116
+ fs.writeFileSync(marker, String(Date.now()), { mode: 0o600 });
117
+ if (n) console.log(`[记忆] 默认改成关闭:升级前的 ${n} 个用户保持开启`);
100
118
  }
101
119
 
102
120
  export function readMemory(userId: string): UserMemory {
@@ -105,7 +123,8 @@ export function readMemory(userId: string): UserMemory {
105
123
  ? raw.items.filter((i): i is MemoryItem => !!i && typeof i.id === "string" && typeof i.text === "string")
106
124
  : [];
107
125
  return {
108
- enabled: raw.enabled !== false,
126
+ // 默认关:后台整理会占订阅额度,夜里还会单独开一个 5 小时窗口。写过的文件都存着 enabled,老用户不受影响
127
+ enabled: raw.enabled === true,
109
128
  // 早先的版本只有一个「自动整理」开关:关着的就是不整理
110
129
  curate: cleanCurate(raw.curate, raw.autoExtract === false ? { ...DEFAULT_CURATE, when: "off" } : DEFAULT_CURATE),
111
130
  chatHistory: raw.chatHistory !== false,
@@ -123,9 +123,9 @@ export type VncCreds = { username?: string; password: string };
123
123
  /**
124
124
  * 作为客户端和 VNC 服务走完版本协商和认证,停在 ClientInit 之前。
125
125
  * 填了用户名就用苹果认证;否则有 VNC 密码认证就用它,再不然不用认证的。
126
- * 失败抛 VncAuthError(认证的问题)或普通 Error(连接断了)
126
+ * 失败抛 VncAuthError(认证的问题)或普通 Error(连接断了)。返回对方的协议版本(如 "RFB 003.889",苹果的)
127
127
  */
128
- export async function vncLogin(r: ByteReader, write: (b: Buffer) => void, creds: VncCreds): Promise<void> {
128
+ export async function vncLogin(r: ByteReader, write: (b: Buffer) => void, creds: VncCreds): Promise<string> {
129
129
  const version = (await r.read(12)).toString("latin1");
130
130
  const m = /^RFB (\d{3})\.(\d{3})\n$/.exec(version);
131
131
  if (!m) throw new VncAuthError("对方不是 VNC 服务");
@@ -149,19 +149,19 @@ export async function vncLogin(r: ByteReader, write: (b: Buffer) => void, creds:
149
149
  const serverKey = await r.read(keyLength);
150
150
  write(ardResponse(generator, prime, serverKey, creds.username, creds.password));
151
151
  if ((await r.read(4)).readUInt32BE(0) !== 0) throw new VncAuthError("Mac 的用户名或密码不对");
152
- return;
152
+ return version.trim();
153
153
  }
154
154
  if (types.includes(TYPE_VNC)) {
155
155
  write(Buffer.from([TYPE_VNC]));
156
156
  const challenge = await r.read(16);
157
157
  write(await vncAuthResponse(creds.password, challenge));
158
158
  if ((await r.read(4)).readUInt32BE(0) !== 0) throw new VncAuthError("VNC 密码不对");
159
- return;
159
+ return version.trim();
160
160
  }
161
161
  if (types.includes(TYPE_NONE)) {
162
162
  write(Buffer.from([TYPE_NONE]));
163
163
  if ((await r.read(4)).readUInt32BE(0) !== 0) throw new VncAuthError("VNC 服务拒绝连接");
164
- return;
164
+ return version.trim();
165
165
  }
166
166
  if (types.includes(TYPE_ARD)) {
167
167
  throw new VncAuthError("这个 VNC 服务要用户名登录(macOS 屏幕共享没开 VNC 密码):在 设置 → 远程控制 里填上 Mac 的用户名和登录密码");
@@ -173,7 +173,7 @@ export async function vncLogin(r: ByteReader, write: (b: Buffer) => void, creds:
173
173
  * 对页面那头装成不用认证的 VNC 服务(3.8,只给安全类型 None)。
174
174
  * login 是和真正的 VNC 服务认证的过程:它失败时把原因当作认证失败告诉页面
175
175
  */
176
- export async function serveNoAuth(r: ByteReader, write: (b: Buffer) => void, login: Promise<void>): Promise<void> {
176
+ export async function serveNoAuth(r: ByteReader, write: (b: Buffer) => void, login: Promise<unknown>): Promise<void> {
177
177
  // 页面那头还没谈完 login 就失败了:先接住,下面 await 时再处理(不然算没人接的 rejection,进程会退出)
178
178
  login.catch(() => {});
179
179
  write(Buffer.from("RFB 003.008\n", "latin1"));
@@ -4,8 +4,10 @@
4
4
  // 隔着公网又卡又费流量,noVNC 的「画质」参数对它也不起作用。这里的做法:
5
5
  // - 和 VNC 服务之间收全分辨率的画面,存成内存里的一份「原画」。VNC 服务在本机时要原始像素(本机不怕大,
6
6
  // macOS 出原始像素比出 ZRLE 快几倍:5K 屏约 1 秒一帧,ZRLE 要 4 秒);在别的机器上时要 ZRLE;
7
- // - macOS 每次都把整屏发过来(哪怕只变了一点):和原画逐格比,真变了的格子才更新原画、
7
+ // - macOS 常常把一整块屏重发一遍(哪怕只变了一点):和原画逐格比,真变了的格子才更新原画、
8
8
  // 按面积平均缩到「输出画面」上,并记下输出画面上哪些格子脏了;
9
+ // - 多块屏时画面是几块屏拼起来的,可以只看其中一块:输出画面只从那块缩出来,也只向 VNC 服务要那一块
10
+ // (各块屏在哪见 desktop-screens.ts;macOS 的要从它发来的画面里学);
9
11
  // - 页面要画面(FramebufferUpdateRequest)时,把脏的格子拼成几个矩形,用 sharp 压成 JPEG,按 Tight 编码发过去;
10
12
  // - 页面发来的鼠标坐标按比例放大回原画的坐标,键盘、剪贴板原样转发。
11
13
  // 对页面来说就是一个分辨率小一些、只用 Tight JPEG 的 VNC 服务(认证由 vnc-auth.ts 在服务端做完)。
@@ -41,10 +43,18 @@ const MAX_RECT_TILES = 8;
41
43
  const FRAME_MS = 40;
42
44
  /** 页面收得慢:WebSocket 里积压到这么多就先不发 */
43
45
  const HIGH_WATER = 2 * 1024 * 1024;
46
+ /** 学各块屏在哪时,比这小的矩形不算一块屏(macOS 在两块屏交界处会夹带几像素宽的细条) */
47
+ const MIN_SCREEN_W = 320;
48
+ const MIN_SCREEN_H = 240;
49
+ /** 学各块屏在哪最多试这么多次更新,学不出来就算了(看整个画面) */
50
+ const LEARN_TRIES = 8;
44
51
 
45
- type Rect = { x: number; y: number; w: number; h: number };
52
+ export type Rect = { x: number; y: number; w: number; h: number };
46
53
 
47
- /** 原画和缩小后的输出画面(都是每像素 4 字节 R G B X),外加输出画面上的脏格子 */
54
+ /**
55
+ * 原画和缩小后的输出画面(都是每像素 4 字节 R G B X),外加输出画面上的脏格子。
56
+ * 原画一直是整个画面;输出画面只从其中的「视野」缩出来(多块屏时只看一块,见 setView)
57
+ */
48
58
  export class Frame {
49
59
  srcW = 0;
50
60
  srcH = 0;
@@ -52,6 +62,10 @@ export class Frame {
52
62
  outH = 0;
53
63
  src = Buffer.alloc(0);
54
64
  out = new Uint8Array(0);
65
+ /** 原画上要看的那一块 */
66
+ view: Rect = { x: 0, y: 0, w: 0, h: 0 };
67
+ /** 输出画面就是原画(整个画面、不用缩):不用另外缩一份 */
68
+ private direct = true;
55
69
  /** 每个输出像素对应原画的哪一段:[x0[i], x1[i]) */
56
70
  private x0 = new Int32Array(0);
57
71
  private x1 = new Int32Array(0);
@@ -70,26 +84,54 @@ export class Frame {
70
84
  this.resize(srcW, srcH);
71
85
  }
72
86
 
87
+ /** 原画换了大小:视野回到整个画面 */
73
88
  resize(srcW: number, srcH: number): void {
74
- const k = Math.min(1, this.edge / Math.max(srcW, srcH, 1));
75
89
  this.srcW = srcW;
76
90
  this.srcH = srcH;
77
- this.outW = Math.max(1, Math.round(srcW * k));
78
- this.outH = Math.max(1, Math.round(srcH * k));
79
91
  this.src = Buffer.alloc(srcW * srcH * 4);
80
- // 不用缩:输出画面就是原画
81
- this.out = this.scaled ? new Uint8Array(this.outW * this.outH * 4) : this.src;
82
- const ranges = (outN: number, srcN: number) => {
92
+ this.view = { x: 0, y: 0, w: srcW, h: srcH };
93
+ this.layout();
94
+ }
95
+
96
+ /** 只看原画上的这一块(null 是整个画面),超出原画的部分截掉。视野变了返回 true(输出画面的大小跟着变) */
97
+ setView(r: Rect | null): boolean {
98
+ let v = { x: 0, y: 0, w: this.srcW, h: this.srcH };
99
+ if (r) {
100
+ const x = Math.max(0, r.x);
101
+ const y = Math.max(0, r.y);
102
+ const w = Math.min(this.srcW, r.x + r.w) - x;
103
+ const h = Math.min(this.srcH, r.y + r.h) - y;
104
+ if (w > 0 && h > 0) v = { x, y, w, h };
105
+ }
106
+ const old = this.view;
107
+ if (v.x === old.x && v.y === old.y && v.w === old.w && v.h === old.h) return false;
108
+ this.view = v;
109
+ this.layout();
110
+ // 原画里已经有的画面先缩过来(刚换大小时原画全黑,不用)
111
+ if (!this.direct) this.downscale(0, 0, this.outW, this.outH);
112
+ return true;
113
+ }
114
+
115
+ /** 按视野算输出画面的大小、对应关系,整个记脏 */
116
+ private layout(): void {
117
+ const { x: vx, y: vy, w: vw, h: vh } = this.view;
118
+ const k = Math.min(1, this.edge / Math.max(vw, vh, 1));
119
+ this.outW = Math.max(1, Math.round(vw * k));
120
+ this.outH = Math.max(1, Math.round(vh * k));
121
+ this.direct = vw === this.srcW && vh === this.srcH && this.outW === vw && this.outH === vh;
122
+ this.out = this.direct ? this.src : new Uint8Array(this.outW * this.outH * 4);
123
+ const ranges = (outN: number, start: number, srcN: number) => {
83
124
  const lo = new Int32Array(outN);
84
125
  const hi = new Int32Array(outN);
85
126
  for (let i = 0; i < outN; i++) {
86
- lo[i] = Math.floor((i * srcN) / outN);
87
- hi[i] = Math.max(lo[i]! + 1, Math.min(srcN, Math.floor(((i + 1) * srcN) / outN)));
127
+ const a = Math.floor((i * srcN) / outN);
128
+ lo[i] = start + a;
129
+ hi[i] = start + Math.max(a + 1, Math.min(srcN, Math.floor(((i + 1) * srcN) / outN)));
88
130
  }
89
131
  return [lo, hi] as const;
90
132
  };
91
- [this.x0, this.x1] = ranges(this.outW, srcW);
92
- [this.y0, this.y1] = ranges(this.outH, srcH);
133
+ [this.x0, this.x1] = ranges(this.outW, vx, vw);
134
+ [this.y0, this.y1] = ranges(this.outH, vy, vh);
93
135
  this.tilesX = Math.ceil(this.outW / TILE);
94
136
  this.tilesY = Math.ceil(this.outH / TILE);
95
137
  this.dirty = new Uint8Array(this.tilesX * this.tilesY);
@@ -97,17 +139,18 @@ export class Frame {
97
139
  this.markOut(0, 0, this.outW, this.outH);
98
140
  }
99
141
 
100
- get scaled(): boolean {
101
- return this.outW !== this.srcW || this.outH !== this.srcH;
102
- }
103
-
104
142
  get hasDirty(): boolean {
105
143
  return this.dirtyCount > 0;
106
144
  }
107
145
 
146
+ /** 视野不是整个画面 */
147
+ get cropped(): boolean {
148
+ return this.view.w !== this.srcW || this.view.h !== this.srcH;
149
+ }
150
+
108
151
  /** 原画上比较变化用的格子边长:对应输出画面上一个脏格子 */
109
152
  private get cell(): number {
110
- return Math.max(TILE, Math.ceil((TILE * this.srcW) / this.outW));
153
+ return Math.max(TILE, Math.ceil((TILE * this.view.w) / this.outW));
111
154
  }
112
155
 
113
156
  /**
@@ -141,14 +184,19 @@ export class Frame {
141
184
  return changed;
142
185
  }
143
186
 
144
- /** 原画上这块变了:缩到输出画面上,记脏 */
187
+ /** 原画上这块变了:视野里的那部分缩到输出画面上,记脏 */
145
188
  damage(x: number, y: number, w: number, h: number): void {
146
- if (w <= 0 || h <= 0) return;
147
- const ox0 = Math.max(0, Math.floor((x * this.outW) / this.srcW));
148
- const oy0 = Math.max(0, Math.floor((y * this.outH) / this.srcH));
149
- const ox1 = Math.min(this.outW, Math.ceil(((x + w) * this.outW) / this.srcW));
150
- const oy1 = Math.min(this.outH, Math.ceil(((y + h) * this.outH) / this.srcH));
151
- if (this.scaled) this.downscale(ox0, oy0, ox1, oy1);
189
+ const v = this.view;
190
+ const sx0 = Math.max(x, v.x) - v.x;
191
+ const sy0 = Math.max(y, v.y) - v.y;
192
+ const sx1 = Math.min(x + w, v.x + v.w) - v.x;
193
+ const sy1 = Math.min(y + h, v.y + v.h) - v.y;
194
+ if (sx1 <= sx0 || sy1 <= sy0) return;
195
+ const ox0 = Math.max(0, Math.floor((sx0 * this.outW) / v.w));
196
+ const oy0 = Math.max(0, Math.floor((sy0 * this.outH) / v.h));
197
+ const ox1 = Math.min(this.outW, Math.ceil((sx1 * this.outW) / v.w));
198
+ const oy1 = Math.min(this.outH, Math.ceil((sy1 * this.outH) / v.h));
199
+ if (!this.direct) this.downscale(ox0, oy0, ox1, oy1);
152
200
  this.markOut(ox0, oy0, ox1 - ox0, oy1 - oy0);
153
201
  }
154
202
 
@@ -243,11 +291,12 @@ export class Frame {
243
291
  return buf;
244
292
  }
245
293
 
246
- /** 输出画面的坐标 → 原画的坐标(鼠标) */
294
+ /** 输出画面的坐标 → 原画的坐标(鼠标),不出视野 */
247
295
  toSrc(x: number, y: number): [number, number] {
248
- const sx = Math.floor(((x + 0.5) * this.srcW) / this.outW);
249
- const sy = Math.floor(((y + 0.5) * this.srcH) / this.outH);
250
- return [Math.min(this.srcW - 1, Math.max(0, sx)), Math.min(this.srcH - 1, Math.max(0, sy))];
296
+ const v = this.view;
297
+ const sx = Math.floor(((x + 0.5) * v.w) / this.outW);
298
+ const sy = Math.floor(((y + 0.5) * v.h) / this.outH);
299
+ return [v.x + Math.min(v.w - 1, Math.max(0, sx)), v.y + Math.min(v.h - 1, Math.max(0, sy))];
251
300
  }
252
301
  }
253
302
 
@@ -389,6 +438,18 @@ export function decodeZrle(d: Buffer, fb: Uint8Array, w: number, h: number): voi
389
438
  // ---------- 会话 ----------
390
439
 
391
440
  export type Endpoint = { reader: ByteReader; write: (b: Buffer) => void };
441
+
442
+ /** 多块屏各在画面的哪里(desktop-screens.ts) */
443
+ export type ScreenSource = {
444
+ /** 已经知道的各块屏(按从左到右排);画面是 w×h 时还不知道就是 null */
445
+ get(w: number, h: number): Rect[] | null;
446
+ /**
447
+ * macOS 屏幕共享:不增量地要整个画面时,它一次发来一整块屏。把这样一次更新里的大矩形交给它学,
448
+ * 学全了返回 true(之后 get 就有了)
449
+ */
450
+ learn(w: number, h: number, rects: Rect[]): boolean;
451
+ };
452
+
392
453
  export type TranscodeOptions = {
393
454
  vnc: Endpoint;
394
455
  /** backlog:已经交给页面、还没发出去的字节数(WebSocket 的 bufferedAmount) */
@@ -397,6 +458,9 @@ export type TranscodeOptions = {
397
458
  quality: DesktopQuality;
398
459
  /** VNC 服务在本机:要原始像素(见文件开头) */
399
460
  local: boolean;
461
+ /** 只看第几块屏(从 1 数,按 screens 的顺序);0、没这块屏或者还不知道各块屏在哪时看整个画面 */
462
+ screen?: number;
463
+ screens?: ScreenSource;
400
464
  /** 两头都握手完了(之后就是正常收发画面) */
401
465
  onReady?: () => void;
402
466
  };
@@ -504,12 +568,13 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
504
568
 
505
569
  // 先和 VNC 服务登录、拿到画面大小;同时对页面走完不用认证的握手
506
570
  const login = (async () => {
507
- await vncLogin(vnc.reader, vnc.write, creds);
571
+ const version = await vncLogin(vnc.reader, vnc.write, creds);
508
572
  // ClientInit:共享(别把别人踢下线)
509
573
  vnc.write(Buffer.from([1]));
510
574
  const init = await vnc.reader.read(24);
511
575
  const name = await vnc.reader.read(init.readUInt32BE(20));
512
- return { w: init.readUInt16BE(0), h: init.readUInt16BE(2), name };
576
+ // 苹果的屏幕共享:多块屏的位置要自己学(见 ScreenSource)
577
+ return { w: init.readUInt16BE(0), h: init.readUInt16BE(2), name, apple: version === "RFB 003.889" };
513
578
  })();
514
579
  login.catch(() => {});
515
580
  await serveNoAuth(
@@ -520,6 +585,18 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
520
585
  const server = await login;
521
586
  const frame = new Frame(server.w, server.h, preset.edge);
522
587
 
588
+ // 多块屏:知道各块屏在哪就只看选的那块;macOS 的还不知道时先学(这期间看整个画面)
589
+ /** 正在学各块屏在哪:要整个画面、不增量 */
590
+ let learning = false;
591
+ let learnTries = 0;
592
+ /** 按选的屏定视野,视野变了返回 true */
593
+ const pickView = (): boolean => {
594
+ const list = opts.screens?.get(frame.srcW, frame.srcH) ?? null;
595
+ learning = !list && server.apple && !!opts.screens && learnTries < LEARN_TRIES;
596
+ return frame.setView((opts.screen && list?.[opts.screen - 1]) || null);
597
+ };
598
+ pickView();
599
+
523
600
  // 我们这头要的格式和编码
524
601
  const bpp = opts.local && opts.quality === "smooth" ? 2 : 4;
525
602
  vnc.write(Buffer.concat([Buffer.from([0, 0, 0, 0]), bpp === 2 ? pixelFormat16() : pixelFormat()]));
@@ -556,6 +633,8 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
556
633
  let cursorChanged = false;
557
634
  /** VNC 服务的第一帧到了:之前原画还是全黑,别发 */
558
635
  let gotFirst = false;
636
+ /** 下一次向 VNC 服务要整个视野(不增量):只看一块屏时挪进来的内容可能是从视野外拷的,那边没要过,不一定是新的 */
637
+ let refresh = false;
559
638
 
560
639
  const pump = (): void => {
561
640
  if (closed || !wanted || sending) return;
@@ -576,7 +655,7 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
576
655
  }
577
656
  sizeChanged = false;
578
657
  if (sendCursor) {
579
- const c = scaleCursor(cursor!, frame.outW / frame.srcW);
658
+ const c = scaleCursor(cursor!, frame.outW / frame.view.w);
580
659
  parts.push(rectHeader(c.hotX, c.hotY, c.w, c.h, ENC_CURSOR), c.pixels, c.mask);
581
660
  count++;
582
661
  }
@@ -615,12 +694,17 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
615
694
  const requestVnc = (incremental: boolean): void => {
616
695
  if (closed) return;
617
696
  lastRequest = Date.now();
697
+ // 学各块屏在哪时要整个画面;只看一块屏时只要那一块
698
+ const r = learning ? { x: 0, y: 0, w: frame.srcW, h: frame.srcH } : frame.view;
618
699
  const b = Buffer.alloc(10);
619
700
  b[0] = 3;
620
- b[1] = incremental ? 1 : 0;
621
- b.writeUInt16BE(frame.srcW, 6);
622
- b.writeUInt16BE(frame.srcH, 8);
701
+ b[1] = incremental && !learning && !refresh ? 1 : 0;
702
+ b.writeUInt16BE(r.x, 2);
703
+ b.writeUInt16BE(r.y, 4);
704
+ b.writeUInt16BE(r.w, 6);
705
+ b.writeUInt16BE(r.h, 8);
623
706
  vnc.write(b);
707
+ refresh = false;
624
708
  };
625
709
 
626
710
  let failure: ((err: unknown) => void) | null = null;
@@ -648,6 +732,8 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
648
732
  const type = (await vnc.reader.read(1))[0];
649
733
  if (type === 0) {
650
734
  const n = (await vnc.reader.read(3)).readUInt16BE(1);
735
+ /** 这次更新里够大的矩形(学各块屏在哪用) */
736
+ const big: Rect[] = [];
651
737
  for (let i = 0; i < n; i++) {
652
738
  const hd = await vnc.reader.read(12);
653
739
  const x = hd.readUInt16BE(0);
@@ -656,7 +742,10 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
656
742
  const h = hd.readUInt16BE(6);
657
743
  const enc = hd.readInt32BE(8);
658
744
  if (enc === ENC_DESKTOP_SIZE) {
745
+ // 分辨率、屏幕的摆法变了:各块屏在哪重新来
659
746
  frame.resize(w, h);
747
+ learnTries = 0;
748
+ pickView();
660
749
  sizeChanged = true;
661
750
  continue;
662
751
  }
@@ -668,6 +757,7 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
668
757
  continue;
669
758
  }
670
759
  if (x + w > frame.srcW || y + h > frame.srcH) throw new Error("VNC 服务发来的矩形超出了画面");
760
+ if (enc !== ENC_COPYRECT && w >= MIN_SCREEN_W && h >= MIN_SCREEN_H) big.push({ x, y, w, h });
671
761
  if (enc === ENC_ZRLE) {
672
762
  const len = (await vnc.reader.read(4)).readUInt32BE(0);
673
763
  const px = scratchOf(w * h * 4);
@@ -693,8 +783,18 @@ export async function transcode(opts: TranscodeOptions): Promise<void> {
693
783
  frame.src.copyWithin((y + row) * stride + x * 4, from, from + w * 4);
694
784
  }
695
785
  frame.damage(x, y, w, h);
786
+ const v = frame.view;
787
+ if (frame.cropped && (sx < v.x || sy < v.y || sx + w > v.x + v.w || sy + h > v.y + v.h)) refresh = true;
696
788
  } else throw new Error(`VNC 服务用了不认识的编码 ${enc}`);
697
789
  }
790
+ if (learning) {
791
+ learnTries++;
792
+ if (opts.screens!.learn(frame.srcW, frame.srcH, big) || learnTries >= LEARN_TRIES) {
793
+ learning = false;
794
+ // 学全了:换到选的那块屏。页面不认 DesktopSize(改不了画面大小)时只能接着看整个画面
795
+ if (pageEnc.desktopSize && pickView()) sizeChanged = true;
796
+ }
797
+ }
698
798
  gotFirst = true;
699
799
  pump();
700
800
  // 下一帧:本机的 VNC 服务会等到画面有变化才回
package/src/main.ts CHANGED
@@ -10,6 +10,8 @@ import { startFeishu, stopFeishu } from "./channels/feishu/index.js";
10
10
  import { startWeb, stopWeb } from "./channels/web/server.js";
11
11
  import { home } from "./home.js";
12
12
  import { startMemoryCurator } from "./core/memory-curator.js";
13
+ import { migrateMemoryDefault } from "./core/memory.js";
14
+ import { listUsers } from "./core/users.js";
13
15
  import { startScheduler, stopScheduler } from "./core/scheduled.js";
14
16
  import { startTaskRunner, stopTaskRunner } from "./core/task-runner.js";
15
17
  import { startTasksBridge, stopTasksBridge } from "./core/tasks-bridge.js";
@@ -44,6 +46,7 @@ async function main(): Promise<void> {
44
46
  });
45
47
 
46
48
  // 聊天记录索引和聊完后的记忆整理
49
+ migrateMemoryDefault(listUsers().map((u) => u.id));
47
50
  startMemoryCurator();
48
51
 
49
52
  startFeishu();
@@ -13,6 +13,7 @@ import { createTouch } from "./desktop-touch.js";
13
13
  // 离开远程控制页时连接不断,画面在后台照常更新;断线了自己重连,点了「断开」才不连。
14
14
  // 手机上:触摸事件由 desktop-touch.js 接管(触控板 / 触摸两种模式、双指本地放大),下面多一排按键。
15
15
  // 画质:除了「原画」,服务端都会把画面缩小、压成 JPEG 再发过来(vnc-transcode.ts),换画质要重连。
16
+ // 多块屏:可以只看其中一块(服务端只截那块再缩),名字是系统里的显示器名称;也只在转码时管用,换屏幕要重连。
16
17
 
17
18
  /** 画质档位:和服务端 DESKTOP_QUALITIES 对应,original 是原样转发 */
18
19
  const QUALITIES = [
@@ -23,9 +24,17 @@ const QUALITIES = [
23
24
  ];
24
25
  const savedQuality = localStorage.getItem("aim.deskQuality");
25
26
 
27
+ /** 连上后问几次有哪几块屏:macOS 的要服务端从画面里学,刚连上时可能还没学到 */
28
+ const MONITOR_POLLS = 6;
29
+
26
30
  const D = {
27
31
  rfb: null,
28
32
  quality: QUALITIES.some(([id]) => id === savedQuality) ? savedQuality : "standard",
33
+ /** 只看第几块屏(从 1 数),0 是全部 */
34
+ monitor: Number(localStorage.getItem("aim.deskMonitor")) || 0,
35
+ /** 远程那边有哪几块屏:[{ name }],不到两块时不显示选屏幕 */
36
+ monitors: [],
37
+ monitorPoll: 0,
29
38
  /** idle / connecting / connected / error */
30
39
  state: "idle",
31
40
  message: "",
@@ -111,7 +120,7 @@ async function connect() {
111
120
  // 等密码的这会儿里点了断开,或者又发起了一次连接(切回前台、点了重连):这次作罢
112
121
  if (!D.want || D.rfb) return;
113
122
  const proto = location.protocol === "https:" ? "wss" : "ws";
114
- const rfb = new RFB(D.screen, `${proto}://${location.host}/ws/desktop?q=${D.quality}`, { credentials: { password }, shared: true, wsProtocols: [] });
123
+ const rfb = new RFB(D.screen, `${proto}://${location.host}/ws/desktop?q=${D.quality}&screen=${D.monitor}`, { credentials: { password }, shared: true, wsProtocols: [] });
115
124
  D.rfb = rfb;
116
125
  rfb.scaleViewport = D.fit;
117
126
  // 不裁剪:原始大小时 noVNC 的画面容器自己出滚动条
@@ -137,6 +146,7 @@ async function connect() {
137
146
  D.backoff = 1000;
138
147
  setLive(true);
139
148
  render();
149
+ loadMonitors(rfb, MONITOR_POLLS);
140
150
  // 第一帧到了画布才有大小
141
151
  setTimeout(() => {
142
152
  D.touch?.connected();
@@ -199,6 +209,20 @@ async function connect() {
199
209
  });
200
210
  }
201
211
 
212
+ /** 问服务端有哪几块屏;还没学到(macOS 的刚连上)就过一会儿再问,连接换了就不问了 */
213
+ function loadMonitors(rfb, left) {
214
+ clearTimeout(D.monitorPoll);
215
+ void api("/api/desktop/screens").then(
216
+ ({ screens }) => {
217
+ if (D.rfb !== rfb) return;
218
+ D.monitors = screens;
219
+ renderTools();
220
+ if (screens.length < 2 && left > 1) D.monitorPoll = setTimeout(() => loadMonitors(rfb, left - 1), 1500);
221
+ },
222
+ () => {},
223
+ );
224
+ }
225
+
202
226
  /** 出错了:retry 为真时按退避重连 */
203
227
  function fail(message, retry) {
204
228
  D.state = "error";
@@ -305,6 +329,7 @@ function renderTools() {
305
329
  tool("发送按键", "command", (e) => openKeysMenu(e.currentTarget), { disabled: !on || D.viewOnly }),
306
330
  tool(D.viewOnly ? "只看(点一下恢复控制)" : "只看不控制", "eye", toggleViewOnly, { on: D.viewOnly }),
307
331
  tool(`画质:${QUALITIES.find(([id]) => id === D.quality)[1]}`, "gauge", (e) => openQualityMenu(e.currentTarget)),
332
+ D.monitors.length > 1 ? tool(`屏幕:${monitorName()}`, "monitor", (e) => openMonitorMenu(e.currentTarget)) : null,
308
333
  // 手机上靠双指放大,不切原始大小
309
334
  isTouch ? null : tool(D.fit ? "原始大小" : "缩放到窗口", D.fit ? "maximize" : "restore", toggleFit),
310
335
  tool("全屏", "expand", () => setFull(true)),
@@ -379,6 +404,30 @@ function openQualityMenu(anchor) {
379
404
  );
380
405
  }
381
406
 
407
+ function monitorName() {
408
+ return D.monitors[D.monitor - 1]?.name ?? "全部屏幕";
409
+ }
410
+
411
+ /** 选只看哪块屏:存下来,连着的话马上重连。原画是原样转发,截不了 */
412
+ function openMonitorMenu(anchor) {
413
+ if (D.quality === "original") return toast("原画是原样转发,只能看全部屏幕;换成流畅、标准或高清才能选", 3000);
414
+ const r = anchor.getBoundingClientRect();
415
+ showMenu(
416
+ { x: r.right - 240, y: r.bottom + 4 },
417
+ [{ name: "全部屏幕" }, ...D.monitors].map(({ name }, i) => ({
418
+ label: `${i === (D.monitors[D.monitor - 1] ? D.monitor : 0) ? "✓ " : "  "}${name}`,
419
+ onclick: () => {
420
+ if (i === D.monitor) return;
421
+ D.monitor = i;
422
+ localStorage.setItem("aim.deskMonitor", String(i));
423
+ renderTools();
424
+ toast(`屏幕:${name}`);
425
+ if (D.want) reconnect();
426
+ },
427
+ })),
428
+ );
429
+ }
430
+
382
431
  function toggleFit() {
383
432
  D.fit = !D.fit;
384
433
  localStorage.setItem("aim.deskFit", D.fit ? "1" : "0");