agent-loft 0.2.85 → 0.2.87

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
@@ -55,7 +55,7 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
55
55
  - 输入框里的小圆环显示上下文窗口占用;模型按钮显示实际的模型和思考程度(如「Opus 5.5 high」)。
56
56
  - 滚动和 ChatGPT 一样:发出的问题顶到最上面、下面留白,回复长到屏幕底部才跟着往下滚;回复过程中自己滚动了就不再自动滚,下次发消息再恢复。
57
57
  - 定时发送:右上角「更多」→「定时发送」,默认排在 5 小时额度重置后 5 分钟(弹窗里提示 5 小时 / 7 天额度的重置时间),由服务端到点发出,关掉页面也会发。适合额度用完、要等刷新才能接着干活的时候。
58
- - 侧栏直接显示各个文件夹,Web 会话按工作目录归类(目录可以拖动排序,右键可置顶;排好的顺序跟着账号走、各设备一致,新消息不会打乱),飞书会话按机器人分组,微信的当前与历史会话按账号分组,两者都能展开 / 折叠并记住状态,收起时仍显示运行中和待处理提示(飞书分组右键仍可看历史会话)。渠道分组行右侧始终显示飞书或微信的静态图标,Web 页面不提供这些分组的新建会话入口。项目名、渠道分组名和有分叉的会话后面有个小三角,点一下折叠 / 展开(分叉折叠后显示「N 个嵌套会话」);分叉出来的会话缩进挂在原会话下面,用一条细线连着;标题放不下时尾巴淡出;Web 和飞书会话都先用首条消息命名,再同步 agent 自动生成的标题,旧飞书会话会从历史记录补名,双击可手动重命名;鼠标移到会话上,行尾显示对应的专家图标;定时任务的时钟图标始终放在最右侧。
58
+ - 侧栏直接显示各个文件夹,Web 会话按工作目录归类(目录可以拖动排序,右键可置顶;排好的顺序跟着账号走、各设备一致,新消息不会打乱),飞书会话按机器人分组,微信的当前与历史会话按账号分组,两者都能展开 / 折叠并记住状态,收起时仍显示运行中和待处理提示,展开即可查看历史会话。渠道分组行右侧始终显示飞书或微信的静态图标,Web 页面不提供这些分组的新建会话入口。项目名、渠道分组名和有分叉的会话后面有个小三角,点一下折叠 / 展开(分叉折叠后显示「N 个嵌套会话」);分叉出来的会话缩进挂在原会话下面,用一条细线连着;标题放不下时尾巴淡出;Web 和飞书会话都先用首条消息命名,再同步 agent 自动生成的标题,旧飞书会话会从历史记录补名,双击可手动重命名;鼠标移到会话上,行尾显示对应的专家图标;定时任务的时钟图标始终放在最右侧。
59
59
  - **搜索**:侧栏「搜索」弹窗,搜全部会话的标题、目录名和聊天内容(不开记忆也能搜),可以按专家筛;电脑和手机上弹窗都固定高度,结果在内部滚动,手机上从底部展开;↑↓ 选、回车打开。
60
60
  - **侧栏菜单**:项目上方的「更多」支持点击或鼠标悬停展开,设置入口也在这里。「编辑侧边栏」可勾选直接显示的菜单、拖动调整顺序,未勾选的收进「更多」;配置跟着账号走,电脑和手机共用。
61
61
  - 会话页顶部标题前是专家的头像,PC 端头像与会话名称字号一致(15px);鼠标停上去或点一下,看专家的说明、模型、能力、当前工作目录和本会话 Token 用量。
@@ -64,6 +64,7 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
64
64
  - 用户消息的复制按钮后有「回退到此处」图标:把这条消息及附件放回输入框,并删除它及之后的聊天内容,重新发送时从之前的上下文继续。
65
65
  - 太长的消息先收起,点「展开显示」看全文;对话里有至少 3 条用户消息时,右侧显示快速定位尺,电脑上鼠标移入查看消息开头、点击跳转;手机上手动滚动时显示短轨道,按住拖动可预览问题和位置,松手跳转,停止操作约 1.6 秒后隐藏。
66
66
  - 回复底部的 token 数自动按大小显示为 K、M 等单位。
67
+ - 项目右键(触屏长按)可「删除项目…」:二次确认后删除文件夹及全部文件、子目录和关联会话,同时清理附件、资料库文件和定时发送;目录选择器里也可删除空文件夹。工作区根目录、包含其他用户会话的目录不能删除,Agent 自己保存的原始会话记录仍保留。
67
68
  - 侧栏按页加载:每个项目目录和飞书机器人分组先显示 5 条,点「展开显示」每次再拉 10 条。
68
69
  - 项目、飞书和微信分组可混合拖拽排序,渠道分组可以放在项目前面或项目之间;右键(触屏长按)可置顶、上移、下移或按最近活跃重排。顺序按账号保存,刷新、换设备后保留,新消息不会改变已排好的位置。
69
70
  - 侧栏底部显示 Claude / Codex 的订阅额度(5 小时 / 7 天窗口,以及多久后重置);关了额度查询就整块不显示。
@@ -90,12 +91,12 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
90
91
  只勾联网搜索、读网页的 Claude 专家就是以前聊天模式的效果。专家改了,用它的对话下一条消息起生效;专家删了,用它的对话还能看、不能再发消息,用它的定时任务暂停。以前的聊天模式取消了:升级后聊天模式的旧对话不再保留,聊天模式的定时任务暂停,选个专家再启用。
91
92
  - **MCP**:设置 → MCP,每人管自己的:本机进程(命令 + 参数 + 环境变量)或 HTTP 地址(+ 请求头),值可以标成密钥(网页上不回显,只交给 MCP 进程或请求头,不进提示词)。可以设「调用前询问」,不设就直接用。自定义专家加载各自勾选的服务;内置专家在「设置 → Agent → 对应 Agent 卡片 → 默认加载」里选择,支持个人 MCP、管理员可选的机器 MCP,也可全部取消;不指定时管理员沿用机器配置。
92
93
  - **记忆**:像 ChatGPT 的记忆,设置 → 记忆(默认关)。「关于我」加上一条条记住的事,每次对话都带上;agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条(回复里会说),记错了用 `forget` 删。**自动整理**:把上次整理之后新说的话交给模型(不留会话记录的一次性调用),补充、更新或删掉过时的记忆,用户自己加的条目它不动。什么时候整理每个人自己定:每天一次(默认凌晨 2 点,把当天的对话合起来一次整理,最省)/每段对话聊完后(停多久可选,改了什么会在对话里说一声)/只在点「现在整理」时/不整理;整理哪些对话也能选:全部/只整理选中专家的对话;用哪个 agent 的哪个模型也能选,默认 Claude Haiku,没有 Claude 就用 Codex 的默认模型、思考程度 low。**参考以前的聊天**:agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话(关键词搜索,只有你自己的、没被删掉的对话)。聊天记录索引不开记忆也会记(侧栏的「搜索」也用它),升级后会把已有对话收录进来一次;没开记忆时记进来的不拿去整理。两项都能在设置里单独关。每个用户一份,Claude 和 Codex、Web 和飞书共用。只用在有主人的对话里:你的 Web 对话,以及绑定了飞书账号后和机器人的私聊;飞书群聊不用。别人(包括管理员)看不到你的记忆,管理员只能清空它;删用户时记忆一起删,不转给管理员。
93
- - **定时任务**:像 ChatGPT 的 Tasks,侧栏的「定时任务」。到点把一段提示词交给 agent,结果发回对话:一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron,按服务端时区,两次至少隔 15 分钟。**有需要才提醒**(默认):agent 自己判断这次有没有要告诉你的事(比如「有新版本才告诉我」),没有就在回复第一行写 `[[静默]]`,推送、飞书都不发,对话里折叠成一行;没写暗号一律照常提醒。结果发到**专用对话**(任务自己的一条对话,第一次运行时新建、之后续用,可选专家和目录),或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」:agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理,新建、修改、删除都会先弹授权卡让你确认(只有暂停不用;没有「总是允许」),任务自己运行的那一轮里不能再建、改、删任务。按人隔离:每人只看得到、改得了自己的任务(最多 30 个),删用户时一起删;到点再核对一次对话还是不是他的,对话被删或换了主人就暂停任务。到点对话在忙(正在回复或挂着授权)就等它,最多 30 分钟;服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话,飞书群聊里没有。
94
+ - **定时任务**:像 ChatGPT 的 Tasks,侧栏的「定时任务」。到点把一段提示词交给 agent,结果发回对话:一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron,按服务端时区,两次至少隔 15 分钟。**有需要才提醒**(默认):agent 自己判断这次有没有要告诉你的事(比如「有新版本才告诉我」),没有就在回复第一行写 `[[静默]]`,推送、飞书都不发,对话里折叠成一行;没写暗号一律照常提醒。结果发到**专用对话**(任务自己的一条对话,第一次运行时新建、之后续用,可选专家和目录;可以设成不携带上下文,每次运行都换新会话,之前的结果还留在对话里,只是 agent 看不到),在专用对话右上角的「更多」里可以直接编辑任务、立即运行,或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」:agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理,新建、修改、删除都会先弹授权卡让你确认(只有暂停不用;没有「总是允许」),任务自己运行的那一轮里不能再建、改、删任务。按人隔离:每人只看得到、改得了自己的任务(最多 30 个),删用户时一起删;到点再核对一次对话还是不是他的,对话被删或换了主人就暂停任务。到点对话在忙(正在回复或挂着授权)就等它,最多 30 分钟;服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话,飞书群聊里没有。
94
95
  - **技能(skills)**:设置 → 技能。技能就是 Claude Code / Codex 用的那种 SKILL.md(可以带脚本和资料),由 agent-loft 按人管理,两个 agent 都能用。**来源**:在页面上写、上传技能包(`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹),或者在对话里让 agent「把刚才的做法存成技能」(agent 用 `create_skill` / `update_skill`,先弹授权卡)。**共享**:新建、编辑时选择「仅自己可见」「指定用户」或「所有人可见」,也可在自己技能的「更多 → 共享」里调整;默认仅自己可见。其他用户在「共享技能」中查看正文和附带文件、安装;安装后出现在「我的技能」,可停用、卸载或重新安装。安装的是作者的同一份技能,更新自动跟随;作者撤回共享后,范围外用户不再可用。只有作者能编辑,管理员可下架自己看得到的共享技能。共享不包含作者填写的变量和密钥,每人使用自己的配置。**使用**:内置专家默认使用你启用的全部技能,也可以在「设置 → Agent」中分别指定 Claude Code / Codex 加载哪些技能;自定义专家只用它选中的;agent 遇到对得上的事自己用。**变量**:技能可以声明要用的环境变量(接口地址、密钥),每个人填自己的值,只注入自己的会话;密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量,agent 看不到值,只能用 `skill_request` 工具让 agent-loft 代发请求(在地址、请求头、请求体里写 `{{变量名}}`),只发往你确认过的地址、不跟随跳转、响应里出现的值会被抹掉;作者后来改了地址,要你再确认一次才放行。**机器上原有的技能**(`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的)只给管理员:成员的会话里看不到、调不了(Claude 用技能白名单,`/技能名` 也会被拦下;Codex 关掉它自己的技能清单),管理员在「设置 → 技能 → 本机技能」里能看到。
95
96
  - **资料库**:像 ChatGPT 的资料库,侧栏的「资料库」。对话里发过的附件、agent 回复里给出的、这一轮新写出来的图片 / 文档 / 音视频(复制一份收进来,之后原文件改了删了不影响)都汇总在这里:按图片 / 文档 / 音视频筛、按文件名搜,点开看大图或下载,「在新对话里用」,单个或批量删除(文件从磁盘上删掉)。从资料库拿到对话里的文件硬链接进那条对话的上传目录,不占双份空间,agent 照常能读。按人隔离,规则同对话:自己的;没主人的对话(飞书群聊等)的归管理员。上传了一直没发出去的一天后清掉;删除会话时立即清理该会话的上传文件和资料库记录,删除原件也会清理复用到其他会话的副本。agent 侧的会话记录仍保留,恢复会话不会恢复已删除的文件。
96
97
  - **远程控制**:侧栏「定时任务」下面的「远程控制」,直接操作这台机器的**桌面**和**终端**,上面一键切换;切回对话时连接留在后台(侧栏入口上亮个小绿点),再进来接着用。这台机器没有图形桌面(服务器、NAS)时只有终端。
97
98
  - 桌面:走 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 的用户名和登录密码(苹果认证,由服务端登录)。
98
- - 终端:新终端开在当前对话的工作目录里,可以开多个标签;`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 上软键盘弹出来时这排键会垫到键盘上面。
99
+ - 终端:进入或刷新页面时不自动连接,点击「连接终端」后接上后台终端,没有现成的才新建;也可直接点击「新建终端」。新终端开在当前对话的工作目录里,可以开多个标签;`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 上软键盘弹出来时这排键会垫到键盘上面。
99
100
  - 管理员能用;成员要管理员在 设置 → 用户 里单独「开通远程控制」。终端、桌面在 设置 → 远程控制 里各有总开关。
100
101
  - **微信 ClawBot**:设置 → 账号 → 微信 →「扫码连接微信」,用手机微信扫码并确认(要求微信 8.0.70 以上,「设置 → 插件」里有 ClawBot;这个功能腾讯还在逐步放量)。每个人连自己的微信,会话归扫码的人,用他的记忆和工具,只认扫码的这个微信号;发送 `/new` 创建独立会话并保留旧记录,Web 微信分组里可以查看和续聊历史;服务端主动连向腾讯,不需要公网地址。微信里发文字或语音(要微信能转成文字),不发过程,只显示「正在输入」,结束后发结果;授权和提问是一条文字,回复数字处理(`1` 允许一次、`0` 拒绝,含义固定),网页上也能处理。`/new`、`/stop`、`/model`、`/expert` 等命令都能用。连接后可在同一设置页的「微信使用的专家」中选择专家并点击「切换专家」,也能在首次发微信消息前选好;已有聊天内容时,切换会创建独立会话并保留旧记录,和微信里的 `/expert` 共用同一份选择。
101
102
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "agent-loft",
3
- "version": "0.2.85",
3
+ "version": "0.2.87",
4
4
  "type": "module",
5
5
  "description": "多个 agent 的工作台:把本机 Claude Code / Codex 放到一处统一管理,用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
6
6
  "keywords": [
@@ -104,6 +104,15 @@ const startedAt = Date.now();
104
104
  /** 上传后先存着,发消息时用 id 认领。一小时没人认领就作废 */
105
105
  const uploads = new Map<string, { key: string; attachment: SavedAttachment; at: number }>();
106
106
 
107
+ /** 单条删除和项目批量删除共用清理规则,保留 agent 自己的文字记录。 */
108
+ function hideConversation(key: string): void {
109
+ updateConversation(key, { hidden: true });
110
+ deleteConversationFiles(key);
111
+ for (const [id, entry] of uploads) if (entry.key === key) uploads.delete(id);
112
+ clearScheduled(key);
113
+ hub.emitEvent(key, { type: "meta" });
114
+ }
115
+
107
116
  /**
108
117
  * 认领上传的附件。有任何一个已失效(id 不认识、不属于这条会话、文件已被删 —— 比如
109
118
  * 另一个浏览器在这期间开了新会话、清掉了上传目录)就整条拒绝,让前端提示重新上传,
@@ -817,7 +826,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
817
826
  if (p.startsWith("/api/terminals") && (await handleTerminalApi(req, res, p, user))) return;
818
827
  if ((p === "/api/remote" || p.startsWith("/api/desktop/")) && (await handleDesktopApi(req, res, p, user))) return;
819
828
 
820
- // ----- 目录选择器:列出或新建工作区内的子目录 -----
829
+ // ----- 工作区目录 -----
821
830
  if (p === "/api/dirs" && method === "GET") {
822
831
  const listing = listWorkspaceDirs(url.searchParams.get("path") ?? "");
823
832
  if (!listing) throw new HttpError(404, `目录不存在,或不在 ${config().workspaceRoot} 之内`);
@@ -845,9 +854,51 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
845
854
  sendJson(res, 201, { path: target });
846
855
  return;
847
856
  }
857
+ if (p === "/api/dirs" && method === "DELETE") {
858
+ const body = await readJsonBody<{ path?: unknown }>(req);
859
+ if (typeof body.path !== "string" || !body.path.trim()) throw new HttpError(400, "请指定要删除的项目目录");
860
+ const target = resolveWorkspacePath(body.path);
861
+ if (!target) throw new HttpError(404, "目录不存在,或不在工作区之内");
862
+ if (target === path.resolve(config().workspaceRoot)) throw new HttpError(403, "不能删除工作区根目录");
863
+ // 不把「删除链接」变成删除它指向的整个项目;工作区根目录本身可以是链接。
864
+ if (target !== path.resolve(config().workspaceRoot, body.path)) throw new HttpError(400, "请从实际项目目录删除,不能通过符号链接删除项目");
865
+ const within = (dir: string) => dir === target || dir.startsWith(target + path.sep);
866
+ const affected = () => listConversations().filter((c) => within(resolveWorkspacePath(c.cwd) ?? c.cwd));
867
+ const convs = affected();
868
+ if (convs.some((c) => !visible(c))) throw new HttpError(403, "此目录下有其他用户的会话,不能删除项目");
869
+ const realTarget = fs.realpathSync(target);
870
+ const identity = fs.statSync(target);
871
+ const keys = convs.map((c) => c.key);
872
+ const keySet = new Set(keys);
873
+ const activity = new Map(convs.map((c) => [c.key, c.activeAt]));
874
+ await Promise.all(convs.map((c) => hub.drop(c.key, "项目已删除")));
875
+ // 等待运行中的会话退出后,再核对目录和会话,避免删除等待期间新建的会话。
876
+ const current = affected();
877
+ const changed = current.length !== convs.length || current.some((c) =>
878
+ !keySet.has(c.key) || !visible(c) || c.activeAt !== activity.get(c.key) || hub.liveSessionId(c.key) !== undefined,
879
+ );
880
+ if (resolveWorkspacePath(body.path) !== target || fs.realpathSync(target) !== realTarget || changed) {
881
+ throw new HttpError(409, "项目内容已变化,请重新确认后删除");
882
+ }
883
+ const now = fs.statSync(target);
884
+ if (identity.dev !== now.dev || identity.ino !== now.ino) {
885
+ throw new HttpError(409, "项目内容已变化,请重新确认后删除");
886
+ }
887
+ try {
888
+ fs.rmSync(target, { recursive: true });
889
+ } catch (err) {
890
+ const code = (err as NodeJS.ErrnoException).code;
891
+ throw new HttpError(code === "EACCES" || code === "EPERM" ? 403 : 400, "无法删除项目文件夹,请检查目录权限后重试");
892
+ }
893
+ for (const c of convs) hideConversation(c.key);
894
+ const dirOrder = setDirOrder(user.id, (getDirOrder(user.id) ?? []).filter((dir) => !within(dir)));
895
+ hub.emit("project-deleted", { owner: user.id, path: target, keys });
896
+ sendJson(res, 200, { path: target, keys, dirOrder });
897
+ return;
898
+ }
848
899
 
849
900
  // ----- 会话 -----
850
- // 侧栏按页拉:recent / dir / bot / weixin 按树分页;bot 不传 limit 时保留历史弹窗的平铺列表。
901
+ // 侧栏按页拉:recent / dir / bot / weixin 按树分页。
851
902
  if (p === "/api/conversations/page" && method === "GET") {
852
903
  const all = hub.list(visible).filter((c) => !c.hidden);
853
904
  const scope = url.searchParams.get("scope");
@@ -862,9 +913,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
862
913
  const bot = url.searchParams.get("bot") ?? "";
863
914
  const list = all.filter((c) => c.channel === "feishu" && c.channelId === bot);
864
915
  const before = parseCursor(url.searchParams.get("at"), url.searchParams.get("key"));
865
- const page = url.searchParams.has("limit")
866
- ? pageOf(list, before, clampLimit(url.searchParams.get("limit"), 5))
867
- : { conversations: list.slice(0, 200), next: null };
916
+ const page = pageOf(list, before, clampLimit(url.searchParams.get("limit"), 5));
868
917
  page.conversations = await hub.backfillFeishuTitles(page.conversations);
869
918
  sendJson(res, 200, page);
870
919
  return;
@@ -977,11 +1026,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
977
1026
  if (!sub && method === "DELETE") {
978
1027
  // agent 侧的文字记录保留;托管附件和资料库文件立即清理,恢复会话也不会恢复文件。
979
1028
  await hub.drop(key, "会话已删除");
980
- updateConversation(key, { hidden: true });
981
- deleteConversationFiles(key);
982
- for (const [id, entry] of uploads) if (entry.key === key) uploads.delete(id);
983
- clearScheduled(key);
984
- hub.emitEvent(key, { type: "meta" });
1029
+ hideConversation(key);
985
1030
  sendJson(res, 200, { ok: true });
986
1031
  return;
987
1032
  }
@@ -312,6 +312,10 @@ function broadcastTasks(owner: string): void {
312
312
  for (const client of clients) if (client.user.id === owner) send(client, { t: "tasks" });
313
313
  }
314
314
 
315
+ function broadcastProjectDeleted(project: { owner: string; path: string; keys: string[] }): void {
316
+ for (const client of clients) if (client.user.id === project.owner) send(client, { t: "project-deleted", path: project.path, keys: project.keys });
317
+ }
318
+
315
319
  /** 某人的终端开了 / 结束了:他开着的页面重新拉终端列表(别的设备上开的也能接上) */
316
320
  function broadcastTerminals(owner: string): void {
317
321
  for (const client of clients) if (client.user.id === owner) send(client, { t: "remote" });
@@ -659,6 +663,7 @@ export async function startWeb(): Promise<void> {
659
663
  heartbeat.unref();
660
664
 
661
665
  hub.on("event", broadcastEvent);
666
+ hub.on("project-deleted", broadcastProjectDeleted);
662
667
  hub.on("event", pushEvent);
663
668
  interactions.on("created", broadcastInteraction);
664
669
  interactions.on("created", pushInteraction);
@@ -710,6 +715,7 @@ function onRevoked(): void {
710
715
  export async function stopWeb(): Promise<void> {
711
716
  authEvents.off("revoked", onRevoked);
712
717
  hub.off("event", broadcastEvent);
718
+ hub.off("project-deleted", broadcastProjectDeleted);
713
719
  hub.off("event", pushEvent);
714
720
  interactions.off("created", broadcastInteraction);
715
721
  interactions.off("created", pushInteraction);
package/src/core/hub.ts CHANGED
@@ -59,6 +59,7 @@ import { mcpEvents } from "./mcp.js";
59
59
  import { isMachineCommand, sessionSkills } from "./skill-runtime.js";
60
60
  import { skillEvents } from "./skills.js";
61
61
  import { isSilentReply } from "./task-prompt.js";
62
+ import { findTask } from "./tasks.js";
62
63
  import { patchWeixinAccount } from "./weixin-accounts.js";
63
64
 
64
65
  // ---------- 事件 ----------
@@ -103,7 +104,11 @@ export type ConvEvent =
103
104
  | { type: "meta" };
104
105
 
105
106
  /** 定时任务发起的一轮(见 core/task-runner.ts) */
106
- export type TaskTurn = { taskId: string; runId: string; title: string; smart: boolean };
107
+ /** fresh:这一轮不带之前的上下文,发出去之前先换新会话 */
108
+ export type TaskTurn = { taskId: string; runId: string; title: string; smart: boolean; fresh?: boolean };
109
+
110
+ /** 每条对话最多接着显示这么多条旧会话:每次打开对话都要全读一遍,不能无限长 */
111
+ const PAST_SESSIONS_KEPT = 50;
107
112
 
108
113
  /** 定时任务的一轮结束了 */
109
114
  export type TaskTurnEnd = TaskTurn & { key: string; status: "notified" | "silent" | "error" | "interrupted"; text: string };
@@ -226,7 +231,7 @@ function withTimeout<T>(p: Promise<T>, what: string, ms = QUERY_TIMEOUT_MS): Pro
226
231
 
227
232
  type Live = { id: number; agent: string; cwd: string; session: AgentSession };
228
233
 
229
- class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }> {
234
+ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "project-deleted": [{ owner: string; path: string; keys: string[] }] }> {
230
235
  private drivers = new Map<string, AgentDriver>();
231
236
  private live = new Map<string, Live>();
232
237
  /**
@@ -1107,6 +1112,15 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1107
1112
  // 清理要等旧会话 dispose,期间可能又点了停止
1108
1113
  if (cancelled()) return dropped();
1109
1114
  }
1115
+ if (task?.fresh) {
1116
+ // 换会话会丢掉进行中的那一轮:到点时核对过不忙,但排队期间可能有人刚发了消息,这次就不跑了
1117
+ if (this.isBusy(key)) return gone("对话正在回复,这次没有运行");
1118
+ await this.drop(key, "定时任务开始新一次运行");
1119
+ this.archiveSession(key);
1120
+ this.emitEvent(key, { type: "meta" });
1121
+ if (waiting.cancelled) return;
1122
+ if (cancelled()) return gone("没有发出(停止了或者会话被切换了)");
1123
+ }
1110
1124
  const blocked = await this.blockedSlash(key, input.text);
1111
1125
  if (waiting.cancelled) return;
1112
1126
  if (blocked) {
@@ -1160,13 +1174,41 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1160
1174
  if (!conv || !(agentBinding(conv).sessionId || agentBinding(conv).forkFrom)) return;
1161
1175
  console.log(`[会话] ${key} 闲置超过 ${config().sessionTtlMs / 3600000} 小时,开新会话`);
1162
1176
  await this.drop(key, "会话已闲置过期");
1163
- updateAgentBinding(key, conv.agent, { sessionId: undefined, forkFrom: undefined, model: undefined, effort: undefined });
1177
+ // 「不携带上下文」的任务对话:运行记录要一直留在对话里,模型也是任务定的,都不能清
1178
+ if (conv.taskId && findTask(conv.taskId)?.freshContext) this.archiveSession(key);
1179
+ else updateAgentBinding(key, conv.agent, { sessionId: undefined, forkFrom: undefined, model: undefined, effort: undefined });
1164
1180
  // 不清上传目录:本次和排在后面的消息可能都带着刚上传的附件。
1165
1181
  // 旧附件留到 /new 或下次启动的清扫时再删。
1166
1182
  this.emitEvent(key, { type: "notice", text: "上次的会话闲置太久,已自动开新会话。" });
1167
1183
  this.emitEvent(key, { type: "meta" });
1168
1184
  }
1169
1185
 
1186
+ /** 当前会话不再续用,但记录留在对话里接着显示。下一条消息会开新会话 */
1187
+ private archiveSession(key: string): void {
1188
+ const conv = getConversation(key);
1189
+ if (!conv) return;
1190
+ const { sessionId, pastSessions = [] } = agentBinding(conv);
1191
+ updateAgentBinding(key, conv.agent, {
1192
+ sessionId: undefined,
1193
+ forkFrom: undefined,
1194
+ ...(sessionId ? { pastSessions: [...pastSessions, sessionId].slice(-PAST_SESSIONS_KEPT) } : {}),
1195
+ });
1196
+ }
1197
+
1198
+ /** 旧会话的记录。不带 anchor:它们已经不是当前会话,不能从这里回退或分叉 */
1199
+ private async pastHistory(conv: Conversation): Promise<HistoryMessage[]> {
1200
+ const driver = this.requireDriver(conv.agent);
1201
+ const out: HistoryMessage[] = [];
1202
+ for (const id of agentBinding(conv).pastSessions ?? []) {
1203
+ try {
1204
+ for (const { anchor: _anchor, ...m } of attachFooters(id, await driver.readHistory(id, conv.cwd))) out.push(m);
1205
+ } catch (err) {
1206
+ console.error(`[历史] 读取旧会话 ${id} 失败:`, err);
1207
+ }
1208
+ }
1209
+ return out;
1210
+ }
1211
+
1170
1212
  /** msg:页面上那条消息的编号和收到时是否排队(见 send 里的 shown) */
1171
1213
  private sendNow(key: string, input: UserInput, tag: TaskTurn | null, msg: { id: string; queued: boolean }): void {
1172
1214
  const fail = (err: unknown) => {
@@ -1255,7 +1297,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1255
1297
  this.markSwitched(key, op.seq);
1256
1298
  const next = this.nextWeixinConversation(conv);
1257
1299
  this.clearFullPermission(next.key);
1258
- updateAgentBinding(next.key, next.agent, { sessionId: undefined, forkFrom: undefined, model: model || undefined, effort: undefined });
1300
+ updateAgentBinding(next.key, next.agent, { sessionId: undefined, forkFrom: undefined, pastSessions: undefined, model: model || undefined, effort: undefined });
1259
1301
  this.emitEvent(next.key, { type: "meta" });
1260
1302
  const runtime = await this.runtimeNow(next.key);
1261
1303
  return `已开新会话(${this.label(conv.agent)},模型 ${runtime.model ?? "默认"}${
@@ -1634,6 +1676,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1634
1676
  if (index < 0 && !firstUnwritten) throw new Error("在会话记录里找不到这条消息,请稍后刷新重试");
1635
1677
  const message = index >= 0 ? history[index]! : { text: live!.type === "user" ? live!.text : "", attachments: live!.type === "user" ? live!.files : [] };
1636
1678
  const kept = index >= 0 ? history.slice(0, index) : [];
1679
+ const past = await this.pastHistory(conv);
1637
1680
  await this.drop(key, "对话已回退");
1638
1681
  const sessionId = index > 0 && source && anchor ? await withTimeout(driver.rewindTo(source, conv.cwd, anchor), "回退会话") : undefined;
1639
1682
  this.markSwitched(key, op.seq);
@@ -1643,7 +1686,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1643
1686
  for (const m of kept) if (m.footer) recordFooter(sessionId, m.text, m.footer);
1644
1687
  }
1645
1688
  const owner = memoryOwnerOf(conv);
1646
- if (owner) replaceConversationRecords(owner, key, kept.flatMap((m) => {
1689
+ if (owner) replaceConversationRecords(owner, key, [...past, ...kept].flatMap((m) => {
1647
1690
  if (m.role === "question") return [];
1648
1691
  const text = [m.text, m.attachments?.length ? `(附件:${m.attachments.map((a) => a.name).join("、")})` : ""].filter(Boolean).join("\n");
1649
1692
  return text.trim() ? [{ k: key, a: conv.agent, r: m.role === "user" ? "u" as const : "a" as const, t: text, ts: m.ts ?? conv.createdAt }] : [];
@@ -1758,14 +1801,16 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1758
1801
  async history(key: string): Promise<HistoryMessage[]> {
1759
1802
  const conv = getConversation(key);
1760
1803
  if (!conv) return [];
1761
- const sessionId = agentBinding(conv).sessionId;
1762
- if (!sessionId) return [];
1804
+ const { sessionId, pastSessions } = agentBinding(conv);
1805
+ if (!sessionId && !pastSessions?.length) return [];
1763
1806
  const driver = this.requireDriver(conv.agent);
1807
+ const past = await this.pastHistory(conv);
1808
+ if (!sessionId) return past;
1764
1809
  try {
1765
- return attachFooters(sessionId, await driver.readHistory(sessionId, conv.cwd));
1810
+ return [...past, ...attachFooters(sessionId, await driver.readHistory(sessionId, conv.cwd))];
1766
1811
  } catch (err) {
1767
1812
  console.error(`[历史] 读取 ${key} 失败:`, err);
1768
- return [];
1813
+ return past;
1769
1814
  }
1770
1815
  }
1771
1816
 
package/src/core/store.ts CHANGED
@@ -20,6 +20,11 @@ export type AgentBinding = {
20
20
  * 拿到不同于它的新会话 id 后清掉。
21
21
  */
22
22
  forkFrom?: string;
23
+ /**
24
+ * 这条对话以前用过、已经不再续用的会话(旧的在前):只用来在页面上接着显示,不进 agent 的上下文。
25
+ * 「不携带上下文」的定时任务每次运行都换新会话,靠它把之前的运行结果留在对话里。
26
+ */
27
+ pastSessions?: string[];
23
28
  };
24
29
 
25
30
  export type Conversation = {
@@ -19,18 +19,20 @@ export function stripSilentMark(text: string): string {
19
19
 
20
20
  export function taskMessage(
21
21
  task: { title: string; prompt: string; notify: "smart" | "always" },
22
- opts: { now?: number; manual?: boolean; version?: string } = {},
22
+ opts: { now?: number; manual?: boolean; version?: string; fresh?: boolean } = {},
23
23
  ): string {
24
24
  const now = opts.now ?? Date.now();
25
25
  const lines = [
26
26
  `这条消息是定时任务「${task.title}」${opts.manual ? "(用户刚才手动点了「立即运行」)" : "到点自动发来的"},现在是 ${formatDateTime(now)}(${serverTimeZone()})。${opts.manual ? "" : "用户此刻多半不在屏幕前,不要向他提问、等他回答。"}`,
27
27
  ...(opts.version ? [`agent-loft 服务端当前版本:${opts.version}。`] : []),
28
- "按上面的要求做;这条对话里以前运行的结果可以拿来对比(比如「和上次比有没有变化」)。",
28
+ opts.fresh
29
+ ? "按上面的要求做;这个任务设置了每次运行都不带之前的上下文,你看不到以前运行的结果,不要假设有过上一次。"
30
+ : "按上面的要求做;这条对话里以前运行的结果可以拿来对比(比如「和上次比有没有变化」)。",
29
31
  ];
30
32
  if (task.notify === "smart") {
31
33
  lines.push(
32
34
  "",
33
- `用户希望只在有需要时才被提醒:如果按上面的要求,这次没有需要告诉他的事(比如没有更新、没有变化、条件没满足),回复的第一行只写 ${SILENT_MARK},后面用一两句话记下这次检查的结果(下次可以对比),他就不会收到通知。`,
35
+ `用户希望只在有需要时才被提醒:如果按上面的要求,这次没有需要告诉他的事(比如没有更新、没有变化、条件没满足),回复的第一行只写 ${SILENT_MARK},后面用一两句话记下这次检查的结果${opts.fresh ? "" : "(下次可以对比)"},他就不会收到通知。`,
34
36
  `有需要告诉他的事时正常回复,开头直接说结论,不要写 ${SILENT_MARK}。`,
35
37
  );
36
38
  }
@@ -148,15 +148,16 @@ function fire(task: Task, manual: boolean, now = Date.now()): string | undefined
148
148
  const permission = task.target.kind === "dedicated" ? hub.applyTaskPermission(key, task.permission) : undefined;
149
149
  const capped = task.target.kind === "dedicated" && task.permission && permission !== task.permission ? `权限只能到「${PERMISSION_LABEL[permission ?? "ask"]}」,按这一级运行` : "";
150
150
  const note = [manual ? "手动运行" : "", capped].filter(Boolean).join(";");
151
+ const fresh = task.target.kind === "dedicated" && !!task.freshContext;
151
152
  const run = pushRun(task, { id: runId(), at: now, status: "running", convKey: key, ...(note ? { note } : {}) });
152
153
  running.set(task.id, { runId: run.id, key, at: now });
153
154
  console.log(`[定时任务] ${task.id}「${task.title}」${manual ? "手动运行" : "到点运行"},发到 ${key}`);
154
155
  hub.send(
155
156
  key,
156
- { text: taskMessage(task, { now, manual, version: RUNNING_VERSION }), attachments: [] },
157
+ { text: taskMessage(task, { now, manual, version: RUNNING_VERSION, fresh }), attachments: [] },
157
158
  { channel: "task", channelId: task.id, name: `定时任务「${task.title}」` },
158
159
  undefined,
159
- { task: { taskId: task.id, runId: run.id, title: task.title, smart: task.notify === "smart" } },
160
+ { task: { taskId: task.id, runId: run.id, title: task.title, smart: task.notify === "smart", ...(fresh ? { fresh } : {}) } },
160
161
  );
161
162
  return undefined;
162
163
  }
@@ -56,6 +56,7 @@ function describeTask(task: Task, convKey: string): string {
56
56
  task.enabled && task.nextRunAt ? `下次 ${formatDateTime(task.nextRunAt)}` : "已暂停",
57
57
  task.notify === "smart" ? "有需要才提醒" : "每次都提醒",
58
58
  `结果发到${whereText(task, convKey)}`,
59
+ ...(task.target.kind === "dedicated" && task.freshContext ? ["每次运行不带之前的上下文"] : []),
59
60
  ...(last ? [`最近一次 ${formatDateTime(last.at)} ${STATUS[last.status] ?? last.status}${last.preview ? `:${last.preview}` : last.note ? `(${last.note})` : ""}`] : []),
60
61
  ].join(" · ") + `\n 提示词:${task.prompt.replace(/\s+/g, " ").slice(0, 200)}`;
61
62
  }
package/src/core/tasks.ts CHANGED
@@ -51,6 +51,8 @@ export type Task = {
51
51
  effort?: string;
52
52
  /** 专用对话的权限级别(见 permission.ts):只有用户在页面上能设。没有就是引擎默认 */
53
53
  permission?: PermissionLevel;
54
+ /** 专用对话每次运行都不带之前的上下文:结果还留在这条对话里,只是 agent 看不到。发到已有对话的不用它 */
55
+ freshContext?: boolean;
54
56
  enabled: boolean;
55
57
  createdAt: number;
56
58
  updatedAt: number;
@@ -145,6 +147,7 @@ export type TaskInput = {
145
147
  effort?: unknown;
146
148
  /** 只有网页接口会给:agent 的工具(tasks-bridge.ts)不开放这个参数,免得 agent 给自己提权 */
147
149
  permission?: unknown;
150
+ freshContext?: unknown;
148
151
  enabled?: unknown;
149
152
  };
150
153
 
@@ -204,6 +207,7 @@ export function createTask(owner: string, input: TaskInput, by: "user" | "agent"
204
207
  ...(str(input.model) ? { model: str(input.model) } : {}),
205
208
  ...(str(input.effort) ? { effort: str(input.effort) } : {}),
206
209
  ...(permission ? { permission } : {}),
210
+ ...(input.freshContext === true ? { freshContext: true } : {}),
207
211
  enabled: input.enabled !== false,
208
212
  createdAt: now,
209
213
  updatedAt: now,
@@ -247,6 +251,10 @@ export function updateTask(owner: string, id: string, patch: TaskInput, now = Da
247
251
  if (permission) next.permission = permission;
248
252
  else delete next.permission;
249
253
  }
254
+ if (patch.freshContext !== undefined) {
255
+ if (patch.freshContext === true) next.freshContext = true;
256
+ else delete next.freshContext;
257
+ }
250
258
  if (patch.enabled !== undefined) next.enabled = patch.enabled !== false;
251
259
  // 专用对话的专家 / 目录变了:旧的那条对话对不上了(对话中途不能换专家),下次新开一条
252
260
  if (
package/web/lib/dom.js CHANGED
@@ -32,6 +32,7 @@ export const ICON = {
32
32
  compose: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H6a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-5"/><path d="M18.4 2.6a2 2 0 0 1 2.9 2.9L12.5 14.3 9 15l.7-3.5Z"/></svg>',
33
33
  send: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round"><path d="M12 19V5M5 12l7-7 7 7"/></svg>',
34
34
  stop: '<svg viewBox="0 0 24 24" fill="currentColor"><rect x="7" y="7" width="10" height="10" rx="1.5"/></svg>',
35
+ play: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M7 5v14l11-7Z"/></svg>',
35
36
  clip: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m21.4 11.6-9.2 9.2a6 6 0 0 1-8.5-8.5l9.2-9.2a4 4 0 0 1 5.7 5.7l-9.2 9.2a2 2 0 0 1-2.8-2.8l8.5-8.5"/></svg>',
36
37
  mic: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="2" width="6" height="12" rx="3"/><path d="M5 10a7 7 0 0 0 14 0M12 17v5"/></svg>',
37
38
  more: '<svg viewBox="0 0 24 24" fill="currentColor"><circle cx="5" cy="12" r="1.8"/><circle cx="12" cy="12" r="1.8"/><circle cx="19" cy="12" r="1.8"/></svg>',
package/web/lib/ws.js CHANGED
@@ -2,7 +2,7 @@ import { h } from "./dom.js";
2
2
  import { api } from "./api.js";
3
3
  import { desktop, framed, S, ui } from "../state.js";
4
4
  import { showAuth } from "../views/auth.js";
5
- import { applyBootstrap, bootstrapQuery, renderSidebar, scheduleSidebar } from "../views/sidebar.js";
5
+ import { applyBootstrap, bootstrapQuery, forgetProject, renderSidebar, scheduleSidebar } from "../views/sidebar.js";
6
6
  import { scheduleQuota } from "../views/quota.js";
7
7
  import { renderTopbar } from "../views/topbar.js";
8
8
  import { applyEvent, openConversation, renderIdleNotice } from "../views/messages.js";
@@ -261,6 +261,9 @@ function onWsMessage(msg) {
261
261
  for (const ix of msg.pending) upsertInteraction(ix);
262
262
  setBusy(msg.busy);
263
263
  return;
264
+ case "project-deleted":
265
+ forgetProject(msg.path, msg.keys);
266
+ return;
264
267
  case "conv":
265
268
  if (S.convs.get(msg.info.key)?.busy && !msg.info.busy) scheduleQuota();
266
269
  S.convs.set(msg.info.key, msg.info);
@@ -2,7 +2,7 @@ import { agentIcon, fill, h, icon, toast } from "../lib/dom.js";
2
2
  import { api } from "../lib/api.js";
3
3
  import { relTime } from "../lib/time.js";
4
4
  import { S, ui } from "../state.js";
5
- import { agentLabel, convTitle, renderSidebar } from "./sidebar.js";
5
+ import { agentLabel, convTitle, forgetProject, renderSidebar } from "./sidebar.js";
6
6
  import { agentCatalog, baseName, catalogDefaults, draftPick, modelName, renderContext, renderTopbar, saveDraftPick, visibleModels } from "./topbar.js";
7
7
  import { closeMenu, confirmDialog, modal, placePopover, showPopover } from "../lib/overlay.js";
8
8
  import { newDraft, openConversation, renderEmpty } from "./messages.js";
@@ -246,6 +246,7 @@ export async function changeCwd(pick) {
246
246
  let seq = 0;
247
247
  let loading = false;
248
248
  let creating = false;
249
+ let deleting = false;
249
250
 
250
251
  const crumbs = h("div", { class: "dir-crumbs" });
251
252
  const list = h("div", { class: "dir-list" });
@@ -280,12 +281,27 @@ export async function changeCwd(pick) {
280
281
  folderName.focus();
281
282
  },
282
283
  }, icon("plus"), "新建文件夹");
284
+ const removeFolder = h("button", {
285
+ type: "button", class: "btn danger small", hidden: true,
286
+ onclick: async () => {
287
+ if (!listing || loading || creating || deleting) return;
288
+ const parent = listing.rel.split(/[\\/]/).slice(0, -1).join("/");
289
+ deleting = true;
290
+ syncActions();
291
+ try {
292
+ if (await deleteProject(listing.path)) await load(parent);
293
+ } finally {
294
+ deleting = false;
295
+ syncActions();
296
+ }
297
+ },
298
+ }, "删除文件夹…");
283
299
  const body = h(
284
300
  "div",
285
301
  { class: "modal-body" },
286
302
  crumbs,
287
303
  manual,
288
- h("div", { class: "dir-actions" }, h("label", { class: "check" }, hiddenBox, "显示隐藏"), newFolder),
304
+ h("div", { class: "dir-actions" }, h("label", { class: "check" }, hiddenBox, "显示隐藏"), newFolder, removeFolder),
289
305
  createForm,
290
306
  list,
291
307
  );
@@ -299,13 +315,13 @@ export async function changeCwd(pick) {
299
315
  });
300
316
 
301
317
  go.onclick = async () => {
302
- if (!listing || loading || creating) return;
318
+ if (!listing || loading || creating || deleting) return;
303
319
  close();
304
320
  if (pick) {
305
321
  pick.onPick(listing.path);
306
322
  return;
307
323
  }
308
- if (draft) {
324
+ if (draft || !S.current) {
309
325
  S.draftCwd = listing.path === listing.root ? null : listing.path;
310
326
  S.draftCwdPicked = true;
311
327
  preloadCommands();
@@ -316,9 +332,11 @@ export async function changeCwd(pick) {
316
332
  };
317
333
 
318
334
  function syncActions() {
319
- go.disabled = loading || creating || !listing || listing.path === current;
320
- newFolder.disabled = loading || creating || !listing;
321
- create.disabled = loading || creating;
335
+ go.disabled = loading || creating || deleting || !listing || listing.path === current;
336
+ newFolder.disabled = loading || creating || deleting || !listing;
337
+ removeFolder.hidden = !listing?.rel;
338
+ removeFolder.disabled = loading || creating || deleting || !listing;
339
+ create.disabled = loading || creating || deleting;
322
340
  cancelCreate.disabled = creating;
323
341
  folderName.disabled = creating;
324
342
  create.textContent = creating ? "创建中…" : "创建";
@@ -326,7 +344,7 @@ export async function changeCwd(pick) {
326
344
 
327
345
  async function createFolder() {
328
346
  const name = folderName.value.trim();
329
- if (!listing || loading || creating || !name) return;
347
+ if (!listing || loading || creating || deleting || !name) return;
330
348
  const my = seq;
331
349
  const parent = listing.path;
332
350
  creating = true;
@@ -502,3 +520,28 @@ export async function deleteConv(key = S.current) {
502
520
  toast(err.message);
503
521
  }
504
522
  }
523
+
524
+ const deletingProjects = new Set();
525
+
526
+ export async function deleteProject(dir) {
527
+ if (!dir || dir === S.workspaceRoot || deletingProjects.has(dir)) return false;
528
+ deletingProjects.add(dir);
529
+ try {
530
+ const sure = await confirmDialog({
531
+ title: "删除项目?",
532
+ sub: dir,
533
+ message: "将删除此文件夹及全部文件、子目录,同时删除其中的所有会话、附件、资料库文件和定时发送,包括尚未展开的会话及复用到其他会话的文件副本,无法恢复。agent 自己保存的会话记录仍会保留。",
534
+ confirmText: "删除项目",
535
+ danger: true,
536
+ });
537
+ if (!sure) return false;
538
+ const data = await api("/api/dirs", { method: "DELETE", body: { path: dir } });
539
+ forgetProject(data.path, data.keys);
540
+ return true;
541
+ } catch (err) {
542
+ toast(`删除项目失败:${err.message}`);
543
+ return false;
544
+ } finally {
545
+ deletingProjects.delete(dir);
546
+ }
547
+ }
@@ -19,7 +19,7 @@ import {
19
19
  stopMarquee,
20
20
  } from "./sidebar.js";
21
21
  import { applyDesktopQuota, loadQuota, renderQuota } from "./quota.js";
22
- import { openBotConversations, openConvContextMenu, runDesktopMenu } from "./topbar.js";
22
+ import { openConvContextMenu, runDesktopMenu } from "./topbar.js";
23
23
  import { syncDraftExpert } from "./experts.js";
24
24
  import { confirmDialog, showMenu } from "../lib/overlay.js";
25
25
  import { applyShellInfo, handleAllowEmbed, HOME, mountSwitcher, refreshShellPush, routeToServer, shellBooted, switchServer } from "../lib/shell.js";
@@ -27,7 +27,7 @@ import { bindScrollWatch, latestConversation, newDraft, openConversation, scroll
27
27
  import { bindFileDrop, renderComposer } from "./composer.js";
28
28
  import { openSearch } from "./conv-search.js";
29
29
  import { createNav } from "./msg-nav.js";
30
- import { renameConv } from "./conv-actions.js";
30
+ import { deleteProject, renameConv } from "./conv-actions.js";
31
31
  import { clearCommandCache, preloadCommands } from "./slash.js";
32
32
  import { releaseForeignPushSub } from "../lib/push.js";
33
33
  import { createSidebarNav } from "./sidebar-nav.js";
@@ -236,7 +236,7 @@ function renderLayout() {
236
236
  });
237
237
  ui.convList.addEventListener("contextmenu", (e) => {
238
238
  // 项目和 IM 分组共用移动菜单;触屏也可以通过长按调整混合顺序。
239
- const bot = e.target.closest?.("[data-bot]")?.dataset.bot;
239
+ const dir = e.target.closest?.("[data-dir]")?.dataset.dir;
240
240
  const group = e.target.closest?.("[data-group]")?.dataset.group;
241
241
  if (group) {
242
242
  const i = sidebarGroups.indexOf(group);
@@ -246,7 +246,7 @@ function renderLayout() {
246
246
  ];
247
247
  const reset = sidebarGroups.length > 1 ? [{ label: "按最近活跃重排", onclick: resetSidebarGroupOrder }] : [];
248
248
  const items = moves.length && reset.length ? [...moves, "sep", ...reset] : [...moves, ...reset];
249
- if (bot) items.push(...(items.length ? ["sep"] : []), { label: "历史会话…", onclick: () => openBotConversations(bot) });
249
+ if (dir && dir !== S.workspaceRoot) items.push(...(items.length ? ["sep"] : []), { label: "删除项目…", danger: true, onclick: () => deleteProject(dir) });
250
250
  if (!items.length) return;
251
251
  e.preventDefault();
252
252
  showMenu({ x: e.clientX, y: e.clientY }, items);
@@ -389,7 +389,33 @@ const MORE_STEP = 10;
389
389
  // next:下一页的游标;null = 没有更多了;undefined = 这个目录还没拉过。
390
390
 
391
391
  /** full:老版本服务端一次给了全部,不用再拉 */
392
- const pages = { recent: { show: RECENT_LIMIT, next: null, loading: false }, dirs: new Map(), bots: new Map(), weixin: new Map(), dirAt: new Map(), full: false };
392
+ const pages = { recent: { show: RECENT_LIMIT, next: null, loading: false }, dirs: new Map(), bots: new Map(), weixin: new Map(), dirAt: new Map(), full: false, revision: 0 };
393
+
394
+ /** 项目删除后清掉分页目录、折叠和排序缓存,其他设备也通过 WebSocket 调用。 */
395
+ export function forgetProject(dir, keys) {
396
+ const within = (value) => value === dir || value?.startsWith(`${dir}/`) || value?.startsWith(`${dir}\\`);
397
+ const removed = new Set(keys);
398
+ pages.revision++;
399
+ for (const key of pages.dirAt.keys()) if (within(key)) pages.dirAt.delete(key);
400
+ for (const key of pages.dirs.keys()) if (within(key)) pages.dirs.delete(key);
401
+ for (const list of ["open", "more", "folded", "order"]) sideState[list] = sideState[list].filter((value) => !within(value));
402
+ sideState.forkFolded = sideState.forkFolded.filter((key) => !removed.has(key));
403
+ saveSideState();
404
+ for (const key of removed) {
405
+ const c = S.convs.get(key);
406
+ if (c) c.hidden = true;
407
+ }
408
+ const resetDraft = within(S.draftCwd);
409
+ if (resetDraft) {
410
+ S.draftCwd = null;
411
+ S.draftCwdPicked = false;
412
+ }
413
+ if (removed.has(S.current) || (!S.current && resetDraft)) {
414
+ S.loadToken++;
415
+ newDraft();
416
+ } else renderSidebar();
417
+ reportDesktop();
418
+ }
393
419
 
394
420
  function dirState(dir) {
395
421
  let st = pages.dirs.get(dir);
@@ -453,6 +479,7 @@ async function fetchPage(st, params) {
453
479
  if (st.loading) return;
454
480
  st.loading = true;
455
481
  st.failed = false;
482
+ const revision = pages.revision;
456
483
  try {
457
484
  const q = new URLSearchParams(params);
458
485
  if (st.next) {
@@ -460,6 +487,7 @@ async function fetchPage(st, params) {
460
487
  q.set("key", st.next.key);
461
488
  }
462
489
  const data = await api(`/api/conversations/page?${q}`);
490
+ if (revision !== pages.revision) return;
463
491
  for (const c of data.conversations) S.convs.set(c.key, c);
464
492
  st.next = data.next;
465
493
  } catch (err) {
@@ -681,7 +709,7 @@ export function renderSidebar() {
681
709
  { class: "proj-row", "data-dir": dir, ...groupDragAttrs(dir) },
682
710
  h(
683
711
  "button",
684
- { class: "conv-item proj", title: `${dir}\n拖动可调整顺序,右键可置顶`, onclick: () => toggleSide("open", dir) },
712
+ { class: "conv-item proj", title: `${dir}\n拖动可调整顺序,右键更多操作`, onclick: () => toggleSide("open", dir) },
685
713
  h("span", { class: "title" }, baseName(dir)),
686
714
  caret(!expanded),
687
715
  expanded ? null : status(convs.map((c) => c.key)),
@@ -238,6 +238,7 @@ function taskCard(t) {
238
238
  h("span", {}, state),
239
239
  h("span", {}, t.notify === "smart" ? "有需要才提醒" : "每次都提醒"),
240
240
  h("span", {}, where),
241
+ t.target.kind === "dedicated" && t.freshContext ? h("span", {}, "不带上下文") : null,
241
242
  t.target.kind === "dedicated" && t.permission ? h("span", { class: t.permission === "full" ? "task-perm-full" : "" }, PERMISSIONS[t.permission].label) : null,
242
243
  t.target.kind === "conv" && t.convPermission === "full" ? h("span", { class: "task-perm-full" }, "跟随对话:完全允许") : null,
243
244
  ),
@@ -259,6 +260,23 @@ async function runNow(t) {
259
260
  }
260
261
  }
261
262
 
263
+ /** 对话页的「更多」菜单:先现拉一遍任务(这时任务页可能还没打开过),改完留在对话里 */
264
+ export async function editTaskById(id) {
265
+ try {
266
+ const data = await api("/api/tasks");
267
+ T.tz = data.tz;
268
+ const task = data.tasks.find((t) => t.id === id);
269
+ if (!task) return toast("这个任务不存在了");
270
+ openTaskForm(task);
271
+ } catch (err) {
272
+ toast(err.message);
273
+ }
274
+ }
275
+
276
+ export function runTaskById(id) {
277
+ return runNow({ id });
278
+ }
279
+
262
280
  async function removeTask(t) {
263
281
  const sure = await confirmDialog({
264
282
  title: `删除「${t.title}」?`,
@@ -421,7 +439,15 @@ export function openTaskForm(task, preset) {
421
439
  permissionValue = permission.value;
422
440
  syncPermission();
423
441
  };
424
- const dedicatedBox = h("div", { class: "task-dedicated" }, field("专家", expert, "到点由这个专家来做。要联网、读文件还是跑命令,看专家的权限(设置 → 专家)。"), cwdField, permissionField);
442
+ // ---- 上下文(只有专用对话有:发到已有对话的要接着你们的聊天)----
443
+ const context = h(
444
+ "select",
445
+ {},
446
+ h("option", { value: "keep", selected: !src.freshContext }, "携带(能看到之前几次运行的内容)"),
447
+ h("option", { value: "fresh", selected: !!src.freshContext }, "不携带(每次都从头开始)"),
448
+ );
449
+ const contextField = field("上下文", context, "不携带时结果还留在这条对话里,只是 agent 看不到,没法和上次对比,也更省 token。");
450
+ const dedicatedBox = h("div", { class: "task-dedicated" }, field("专家", expert, "到点由这个专家来做。要联网、读文件还是跑命令,看专家的权限(设置 → 专家)。"), cwdField, permissionField, contextField);
425
451
  const followField = convTarget
426
452
  ? field("权限", h("div", { class: "task-static" }, `跟随这条对话(现在是「${task.convPermission ? PERMISSIONS[task.convPermission].label : "默认"}」)`), "要单独设权限,把结果改发到专用对话。")
427
453
  : null;
@@ -487,7 +513,7 @@ export function openTaskForm(task, preset) {
487
513
  schedule,
488
514
  notify: notify.value,
489
515
  target: dedicated ? { kind: "dedicated" } : { kind: "conv", key: task.target.key },
490
- ...(dedicated ? { expert: expert.value, cwd: findExpert(expert.value)?.access === "web" ? "" : cwd, permission: level } : {}),
516
+ ...(dedicated ? { expert: expert.value, cwd: findExpert(expert.value)?.access === "web" ? "" : cwd, permission: level, freshContext: context.value === "fresh" } : {}),
491
517
  };
492
518
  save.disabled = true;
493
519
  try {
@@ -496,7 +522,7 @@ export function openTaskForm(task, preset) {
496
522
  close();
497
523
  toast(task ? "已保存" : "已创建");
498
524
  if (S.view === "tasks") void reload();
499
- else void openTasks();
525
+ else if (!task) void openTasks();
500
526
  } catch (err) {
501
527
  save.disabled = false;
502
528
  toast(err.message);
@@ -12,7 +12,8 @@ import { attachTermTouch } from "./terminal-touch.js";
12
12
  // ---------- 网页终端 ----------
13
13
  // shell 跑在服务端(core/terminals.ts),这里每个标签一条 /ws/term 连接。
14
14
  // 两种摆法:放在远程控制页里(embed),或者对话下面的底部面板(dock,Ctrl+`)。是同一块面板,挪个地方而已。
15
- // 离开远程控制页、关掉面板、刷新页面都不结束 shell,下次打开时按服务端的列表接上;点标签上的 × 才结束。
15
+ // 进来时不自动连接,点「连接终端」后按服务端列表接上,没有现成的才新建。
16
+ // 离开远程控制页、关掉面板、刷新页面都不结束 shell;刷新后仍需手动连接,点标签上的 × 才结束。
16
17
 
17
18
  const T = {
18
19
  /** closed:藏起来(shell 照常跑)/ dock:底部面板 / embed:在远程控制页里 */
@@ -23,6 +24,8 @@ const T = {
23
24
  ctrl: false,
24
25
  alt: false,
25
26
  loaded: false,
27
+ want: false,
28
+ connecting: false,
26
29
  };
27
30
 
28
31
  const narrow = () => matchMedia("(max-width: 768px)").matches;
@@ -179,7 +182,12 @@ function renderEmptyPane() {
179
182
  { class: "term-empty" },
180
183
  status.available === false
181
184
  ? h("div", { class: "error-text" }, status.reason ?? "这台服务器上终端用不了")
182
- : [h("div", { class: "muted" }, "没有开着的终端"), h("button", { class: "btn", onclick: () => void newTab() }, icon("plus"), "新建终端")],
185
+ : [
186
+ h("div", { class: "muted" }, T.want ? "没有开着的终端" : "终端未连接"),
187
+ T.want && !T.connecting
188
+ ? h("button", { class: "btn", onclick: () => void newTab() }, icon("plus"), "新建终端")
189
+ : h("button", { class: "btn primary", disabled: T.connecting, onclick: () => void connectTerminals() }, icon("plug"), T.connecting ? "连接中…" : "连接终端"),
190
+ ],
183
191
  ),
184
192
  );
185
193
  }
@@ -228,8 +236,21 @@ export function hide() {
228
236
 
229
237
  // ---------- 标签 ----------
230
238
 
239
+ async function connectTerminals() {
240
+ if (T.connecting) return;
241
+ T.want = true;
242
+ T.connecting = true;
243
+ renderEmptyPane();
244
+ try {
245
+ await loadTabs({ create: true });
246
+ } finally {
247
+ T.connecting = false;
248
+ renderEmptyPane();
249
+ }
250
+ }
251
+
231
252
  /** 按服务端的列表对一下:别的设备开的接上,已经结束的标出来 */
232
- async function loadTabs() {
253
+ async function loadTabs({ create = false } = {}) {
233
254
  let data;
234
255
  try {
235
256
  data = await api("/api/terminals");
@@ -239,16 +260,16 @@ async function loadTabs() {
239
260
  }
240
261
  if (S.remote) S.remote.terminal = { enabled: data.enabled, allowed: data.allowed, available: data.available, reason: data.reason, keepAliveMin: data.keepAliveMin };
241
262
  if (!data.allowed) return revoked();
263
+ T.loaded = true;
264
+ if (!T.want) return renderEmptyPane();
242
265
  const ids = new Set(data.terminals.map((t) => t.id));
243
266
  for (const tab of T.tabs) if (!ids.has(tab.id) && !tab.ended) ended(tab, "已经结束了");
244
267
  for (const t of data.terminals) if (!T.tabs.some((tab) => tab.id === t.id)) addTab(t, false);
245
- // 第一次打开、一个都没有:直接开一个
246
- if (!T.loaded && T.tabs.length === 0 && data.available) {
247
- T.loaded = true;
268
+ // 用户手动连接、一个都没有:开一个;打开页面和同步列表不新建。
269
+ if (create && T.tabs.length === 0 && data.available) {
248
270
  await newTab();
249
271
  return;
250
272
  }
251
- T.loaded = true;
252
273
  if (!T.active && T.tabs.length) select(T.tabs[T.tabs.length - 1]);
253
274
  renderHead();
254
275
  renderEmptyPane();
@@ -256,6 +277,7 @@ async function loadTabs() {
256
277
 
257
278
  async function newTab() {
258
279
  ensureDock();
280
+ T.want = true;
259
281
  // 先按面板现在的大小算好行列,shell 一开始就是对的宽度
260
282
  const probe = T.active?.fit.proposeDimensions();
261
283
  let info;
@@ -265,6 +287,7 @@ async function newTab() {
265
287
  toast(err.message);
266
288
  return;
267
289
  }
290
+ T.loaded = true;
268
291
  if (T.mode === "closed") {
269
292
  if (narrow()) return void openRemote("terminal");
270
293
  setMode("dock");
@@ -488,11 +488,22 @@ export function updateCtxVisibility() {
488
488
  if (ui.ctxBar) ui.ctxBar.hidden = !!S.current && (S.items.length > 0 || sentKeys.has(S.current));
489
489
  }
490
490
 
491
+ /** 定时任务页是按需加载的(见 layout.js 的 openTasksView) */
492
+ function withTasks(fn) {
493
+ return import("./tasks.js").then(fn, (err) => toast(`定时任务页加载失败,刷新页面再试:${err.message}`));
494
+ }
495
+
491
496
  /** 顶栏和侧栏共用的会话操作,显示条件和行为保持一致。 */
492
497
  function convMenuItems(key) {
493
498
  const c = S.convs.get(key);
494
499
  if (!c) return [];
495
500
  return [
501
+ ...(c.taskId
502
+ ? [
503
+ { id: "task-edit", label: "编辑定时任务", icon: "edit", onclick: () => withTasks((m) => m.editTaskById(c.taskId)) },
504
+ { id: "task-run", label: "立即运行", icon: "play", onclick: () => withTasks((m) => m.runTaskById(c.taskId)) },
505
+ ]
506
+ : []),
496
507
  {
497
508
  id: "fork",
498
509
  label: "分叉",
@@ -568,42 +579,3 @@ async function continueInFeishu(key) {
568
579
  }),
569
580
  );
570
581
  }
571
-
572
- /** 飞书机器人的历史会话:独立于侧栏分页拉取,按活跃时间排,点一下打开 */
573
- export async function openBotConversations(botId) {
574
- const bot = S.bots.find((b) => b.id === botId);
575
- const body = h("div", { class: "modal-body" }, h("span", { class: "spinner" }));
576
- const close = modal({ title: `历史会话${bot ? ` · ${bot.name}` : ""}`, body });
577
- let convs;
578
- try {
579
- convs = (await api(`/api/conversations/page?${new URLSearchParams({ scope: "bot", bot: botId })}`)).conversations;
580
- } catch (err) {
581
- fill(body, h("div", { class: "error-text" }, err.message));
582
- return;
583
- }
584
- for (const c of convs) S.convs.set(c.key, c);
585
- fill(
586
- body,
587
- ...(convs.length === 0
588
- ? [h("div", { class: "muted" }, "还没有会话")]
589
- : convs.map((c) =>
590
- h(
591
- "button",
592
- {
593
- class: `list-item${c.key === S.current ? " on" : ""}`,
594
- onclick: () => {
595
- close();
596
- if (c.key !== S.current) void openConversation(c.key);
597
- },
598
- },
599
- h(
600
- "div",
601
- { class: "grow" },
602
- h("div", { class: "t" }, convTitle(c)),
603
- h("div", { class: "s" }, `${relTime(c.activeAt)} · ${agentLabel(c.agent)} · ${c.cwd}`),
604
- ),
605
- c.key === S.current ? "当前" : c.busy ? h("span", { class: "conv-spin", title: "进行中" }) : null,
606
- ),
607
- )),
608
- );
609
- }