9 Commits
Author SHA1 Message Date
kicer 2a760ab8a4 fix(preview): 桌面预览的 blob URL 不再建好即撤,修 Chrome 图片/PDF 报 ERR_FILE_NOT_FOUND
openFilePreview 把新建的 blob URL 直接写进 pvState.blobUrl,随后 show() 内部先调
pvClearBody(),把刚建的这个 URL 一并 revoke 掉;img/iframe 的加载在此之后才发起,
于是取到已失效的 blob(Chrome: net::ERR_FILE_NOT_FOUND,Safari 撤回更宽松才没暴露)。
改为先存局部 newBlobUrl,show() 之后再登记;序号已过期则立即撤销防泄漏。
2026-10-21 15:59:28 +08:00
kicer 955e550b29 feat(mcp): 增加 mode=skill,把 MCP 工具以技能形式暴露
mode 三态改为 advertise / skill / disable:
- skill 不下发到 tools 数组,由 skill 工具的 list/get/run 暴露
- get 返回 MCP 原始的 description + input_schema;run 直接转发,不做路径改写与 required 预检
- 移除 mode: silent(不设专门迁移文案)与 front matter mcp_tool 包装
- 删除 skills/image、skills/video,改由 image_task / video_task 的 mode: skill 提供
- 技能清单改用 listCallableSkills(目录 + MCP,同名时目录胜出);设置页仍只列目录
- init.sh 配了 BIGMODEL_KEY 时给 image_task / video_task 写 mode: skill
- image_task / video_task 的 tool description 首行改为自解释的一句话(技能清单取首行)
2026-10-21 11:01:50 +08:00
kicer 76a0e9ad86 refactor(skill): 参数改为动词作键,去掉 op/name/input_args
形状:{"list":"all"} / {"get":"<名>"} / {"run":"<名>","args":{...}},三者恰好给一个。
- 互斥无法用 required 表达,校验与报错回显放在 toolSkill
- list 取值是字符串范围而非布尔,为将来的技能分类留扩展位;今天只认 all
- list/get 带非空 args 一律报错,不静默丢弃
- 旧形状 {op,name,input_args} 仍由 toolSkill 兜底翻译,只为兼容存量技能文档,不再对外文档化
- README/AGENTS/skills 文档与内置技能调用示例同步为新形态
2026-10-21 09:25:25 +08:00
kicer 767caa8574 feat(skills): 技能支持 MCP 后端(front matter mcp_tool)
SKILL.md 声明 mcp_tool 时,op=run 不落 executor 沙箱,由 core 直接 mcp.callTool
转发:凭证留在 core(沙箱的 env 白名单本就会丢掉 *KEY/*TOKEN),模型只看到技能清单
里的一行描述。配合 mcp_servers[].mode: silent,工具不再进每轮请求的 tools 数组。

- skills.js: runSkill 在 absolutizeArgs 之前分流(否则 URL / 含斜杠的 prompt 会被
  当路径改写);不做 input_schema.required 预检(参数与 op 相关,交给 MCP 服务)
- listSkills 带出 mcp_tool;设置页技能卡显示 mcp 后端徽章
- server.js: 启动期自检,缺失后端 warn、两条路并存 info
- 新增 skills/image、skills/video 两个纯文档技能(无 run.py)
- skills/README、README、app/AGENTS 同步
2026-10-21 09:08:57 +08:00
kicer 5d5482891f feat(mcp): mcp_servers 增加 mode 三态(advertise/silent/disable)
silent 让工具只进 toolIndex、不进 toolDefs:模型看不到,技能与 lab 仍可调用,
用于把能力包在技能后面、省掉每轮 schema。disable 连 tools/list 都不发。
旧字段 enable 直接报错而非静默忽略(未知键会被丢弃,导致以为关掉的服务照常连)。

- config.js: mode 三值校验 + enable 废弃守卫
- mcp.js: disable 跳过加载;silent 注册不下发;启动日志区分
- 设置页: 勾选框改为三选一;advertise 时删键,不把默认值写进文件
- init.sh / 示例配置 / README / AGENTS.md 同步
2026-10-21 08:50:01 +08:00
kicer fcc9ebc519 fix(memory): recall 头部去掉 title
renderFrag 不再拼会话标题,search/day/开场注入统一为 ## id=..., date=...;标题是会话名,容易把回忆带偏。顺带删掉只服务标题的 sessions join。
2026-10-21 03:37:53 +08:00
kicer 0427606f24 refactor(time): 业务时区收敛到 server/time.js
新增 time.js 作为 TZ/dayString/stampString/fmtTime/fmtIso 的单一入口;memory/scheduler/db 改为引用,scheduler 继续转出 fmtTime/fmtIso,executor 调用不变。Dockerfile/compose 的 TZ 仍只负责进程默认本地时区,业务 day/cron 固定上海。
2026-10-21 03:33:50 +08:00
kicer 26aa492a14 feat(memory): 日记碎片记录最后对话时刻并渲染 date/title
memory_fragments 新增 last_active_at,收口时快照最后一条真实 user/assistant 消息时刻,day 由它派生;存量数据按 day 匹配回填,匹配不上留 NULL。renderFrag 输出 id + date(YYYY-MM-DD HH:MM:SS) + title(读时 join sessions),缺失时降级为只显示日期/省略标题。recall op=day 的 date 容忍完整时间戳,只截取并校验日期部分。
2026-10-21 03:26:35 +08:00
kicer 03d77ae980 fix(memory): recall op=day 补齐 day 列
dayEntry 的 SELECT 漏选 day,renderFrag 读到 undefined,导致 recall op=day 输出 day=undefined;search/journalFor 查询带 day 未受影响。
2026-10-21 03:10:45 +08:00
28 changed files with 462 additions and 174 deletions
+17 -5
View File
@@ -61,7 +61,7 @@ PUBLIC_IP=1.2.3.4 \
- `.env`:`EXECUTOR_TOKEN`、`WXBOT_TOKEN`、`AGENT_PORT` 等部署变量。 - `.env`:`EXECUTOR_TOKEN`、`WXBOT_TOKEN`、`AGENT_PORT` 等部署变量。
- `config.yml`:模型平台、登录账号、MCP 服务、公网前缀。 - `config.yml`:模型平台、登录账号、MCP 服务、公网前缀。
`image_task` / `video_task` 两个 MCP 服务复用 `BIGMODEL_KEY`(智谱与 BigModel 是同一个 key);未配置 `BIGMODEL_KEY` 时它们以 `enable: false` 写入配置。 `image_task` / `video_task` 两个 MCP 服务复用 `BIGMODEL_KEY`(智谱与 BigModel 是同一个 key);未配置 `BIGMODEL_KEY` 时它们以 `mode: disable` 写入配置。
`AUTH_USER` / `AUTH_PASSWORD` 不传时默认是 `admin` / `admin`,首次部署务必改掉。 `AUTH_USER` / `AUTH_PASSWORD` 不传时默认是 `admin` / `admin`,首次部署务必改掉。
@@ -110,6 +110,16 @@ mcp_servers:
接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。 接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。
每个服务可用 `mode` 控制「工具是否下发给模型」:
| `mode` | 连接/发现 | 进 tools 数组 | 进技能清单 | 谁可以调用 |
|---|---|---|---|---|
| `advertise`(默认) | ✓ | ✓ | ✗ | 模型与技能 |
| `skill` | ✓ | ✗ | ✓ | `skill` 工具与 `lab` |
| `disable` | ✗ | ✗ | ✗ | 无人 |
`skill` 用于「能力包在技能后面」的场景:工具照常发现并注册,只是不进模型的 tools 数组,改为以技能形式暴露——`{"list":"all"}` 能看到它,`{"get":"<名>"}` 直接返回 MCP 原始的 `description` + `input_schema`,`{"run":"<名>","args":{…}}` 转发给服务。不用在 `skills/` 里建目录。旧字段 `enable` 已废弃,`mode: silent` 已移除(启动会报错并提示改用 `skill`)。
工具发现只在启动时做一次,因此发现失败后会自动按 **2s / 20s / 1min 重试 3 次**(覆盖 compose 并行拉起与宿主机重启后的容器乱序);成功后工具在下一轮请求即可用,三次都失败则需重启 core。三个 MCP 服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。 工具发现只在启动时做一次,因此发现失败后会自动按 **2s / 20s / 1min 重试 3 次**(覆盖 compose 并行拉起与宿主机重启后的容器乱序);成功后工具在下一轮请求即可用,三次都失败则需重启 core。三个 MCP 服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。
--- ---
@@ -186,7 +196,7 @@ mcp_servers:
| `model_profiles` | prompt + 工具名单组合;模型用 `profile: <名>` 引用 | | `model_profiles` | prompt + 工具名单组合;模型用 `profile: <名>` 引用 |
| `tools_deny` | 全局工具黑名单,默认屏蔽元工具 `lab` | | `tools_deny` | 全局工具黑名单,默认屏蔽元工具 `lab` |
| `auth` | 登录账号、`secret`、有效期;留空则不启用认证 | | `auth` | 登录账号、`secret`、有效期;留空则不启用认证 |
| `mcp_servers` | 外部 MCP 服务:`url`、`headers`、`enable`、`timeout_ms`、工具名单 | | `mcp_servers` | 外部 MCP 服务:`url`、`headers`、`mode`(advertise / skill / disable)、`timeout_ms`、工具名单 |
| `public_link` | 公网临时链接前缀与有效期 | | `public_link` | 公网临时链接前缀与有效期 |
| `agent` | 温度、最大工具迭代、重试、语言、压缩阈值、空闲收口、历史裁剪 | | `agent` | 温度、最大工具迭代、重试、语言、压缩阈值、空闲收口、历史裁剪 |
| `memory` | 日记注入条数、保留期、空闲收口阈值 | | `memory` | 日记注入条数、保留期、空闲收口阈值 |
@@ -253,7 +263,7 @@ platforms:
| `terminal` | 执行 shell 命令;默认在会话目录,超时可终止 | | `terminal` | 执行 shell 命令;默认在会话目录,超时可终止 |
| `fetch` | 抓取 HTTP/HTTPS 并转 Markdown;带 SSRF 防护与分段续读 | | `fetch` | 抓取 HTTP/HTTPS 并转 Markdown;带 SSRF 防护与分段续读 |
| `mint_public_link` | 为会话内文件签发短期公网链接 | | `mint_public_link` | 为会话内文件签发短期公网链接 |
| `skill` | 技能 `list` / `get` / `run` | | `skill` | 技能:`{"list":"all"}` / `{"get":"<名>"}` / `{"run":"<名>","args":{...}}`(动词作键,三选一) |
| `db` | 操作会话本地 `data.db`:`exec`、`query`、`insert`、`tables`、`schema` | | `db` | 操作会话本地 `data.db`:`exec`、`query`、`insert`、`tables`、`schema` |
| `schedule` | 定时任务 `get` / `list` / `create` / `update` / `delete` | | `schedule` | 定时任务 `get` / `list` / `create` / `update` / `delete` |
| `profile` | 用户画像 `list` / `set` / `add` / `remove` | | `profile` | 用户画像 `list` / `set` / `add` / `remove` |
@@ -271,13 +281,15 @@ platforms:
```text ```text
skills/my-skill/ skills/my-skill/
├── SKILL.md # 必需:描述、input_schema、可选 required / visit_url ├── SKILL.md # 必需:描述、input_schema、可选 required / visit_url
├── run.py | run.sh # 必需:入口,唯一命令行参数是 JSON 字符串 ├── run.py | run.sh # 入口,唯一命令行参数是 JSON 字符串
├── requirements.txt # 可选:Python 依赖 ├── requirements.txt # 可选:Python 依赖
└── install.sh # 可选:系统层安装脚本,镜像构建期执行 └── install.sh # 可选:系统层安装脚本,镜像构建期执行
``` ```
- `SKILL.md` 的 `description` 会进入 system prompt,模型启动时就知道有哪些技能。 - `SKILL.md` 的 `description` 会进入 system prompt,模型启动时就知道有哪些技能。
- `input_schema.required` 在 `skill op=run` 前校验。 - `input_schema.required` 在 `{"run":"<名>","args":{...}}` 前校验。
- MCP 工具不用建目录:给该服务配 `mode: skill`,平台会自动把它暴露成技能(`get` 返回 MCP 原始的
`input_schema`,`run` 转发),见上文「同栈 MCP 服务」。
- 入口脚本以绝对路径启动;远端执行时 cwd 是会话目录,本地开发时是技能目录。相对路径参数会先按会话目录转成绝对路径。 - 入口脚本以绝对路径启动;远端执行时 cwd 是会话目录,本地开发时是技能目录。相对路径参数会先按会话目录转成绝对路径。
- `requirements.txt` 的依赖由 `agent-executor-init` 安装到 `skills/deps`;技能容器通过 `PYTHONPATH` 可见。 - `requirements.txt` 的依赖由 `agent-executor-init` 安装到 `skills/deps`;技能容器通过 `PYTHONPATH` 可见。
- `install.sh` 在镜像构建期以 root 执行,用于必须落在系统层的依赖。改完需要重建 executor 镜像。 - `install.sh` 在镜像构建期以 root 执行,用于必须落在系统层的依赖。改完需要重建 executor 镜像。
+18 -4
View File
@@ -52,7 +52,8 @@ AGENT_CONFIG=./config.yml node server/server.js
| `server/routes/*.js` | HTTP API,按资源分文件 | | `server/routes/*.js` | HTTP API,按资源分文件 |
| `server/sse.js` | 按会话分组的 SSE 总线(`addClient`/`emit`/`onInternal`) | | `server/sse.js` | 按会话分组的 SSE 总线(`addClient`/`emit`/`onInternal`) |
| `server/auth.js` | HMAC cookie 登录、Basic 兜底、`requireAdmin`、免认证路径 | | `server/auth.js` | HMAC cookie 登录、Basic 兜底、`requireAdmin`、免认证路径 |
| `server/memory.js` | 长期记忆(日记碎片)读写与检索,零业务依赖 | | `server/memory.js` | 长期记忆(日记碎片)读写与检索,仅依赖 `time.js` |
| `server/time.js` | 业务时区单一入口:`TZ`、`dayString`、`stampString`、`fmtTime`、`fmtIso` |
| `server/user-profile.js` | 用户画像读写、会话快照冻结 | | `server/user-profile.js` | 用户画像读写、会话快照冻结 |
| `server/public-files.js` | `mint_public_link` 的短链签发与解析(进程内 Map) | | `server/public-files.js` | `mint_public_link` 的短链签发与解析(进程内 Map) |
| `server/download-token.js` | 浏览器下载链接的 HMAC 签名(密钥进程内随机) | | `server/download-token.js` | 浏览器下载链接的 HMAC 签名(密钥进程内随机) |
@@ -157,6 +158,11 @@ POST /api/sessions/:id/messages
白名单、`tools_deny` 黑名单(**deny 赢**;profile 不配 deny 时继承全局 `tools_deny`)。 白名单、`tools_deny` 黑名单(**deny 赢**;profile 不配 deny 时继承全局 `tools_deny`)。
`tools_allow: []` = 零工具(纯文本组合)。过滤只影响"模型看得到什么",名单外工具若真被调用, `tools_allow: []` = 零工具(纯文本组合)。过滤只影响"模型看得到什么",名单外工具若真被调用,
`executeTool` 仍会执行(不误杀)。 `executeTool` 仍会执行(不误杀)。
- MCP 服务按 `mcp_servers[].mode` 参与:`advertise`(默认)进 `toolDefs` 下发;`skill` 只进
`toolIndex`(`mcp.hasTool` 为真,`lab` 可调),且由 `skills.js` 自动
包装成技能(`mcp.skillTools()` / `getSkillTool()`,get 返回注册表里的原始 inputSchema);
`disable` 连 `tools/list` 都不发。旧字段 `enable` 已废弃,`mode: silent` 已移除,
出现即报配置错(不静默忽略)。
- `executeTool(baseCtx, name, args)`:先查 `HANDLERS` 表,未命中再交给 MCP 注册表。 - `executeTool(baseCtx, name, args)`:先查 `HANDLERS` 表,未命中再交给 MCP 注册表。
`ctx = {sessionId, taskDir, run, cfg, db, vision}`;工具返回字符串,`read_file` 读图时返回 `ctx = {sessionId, taskDir, run, cfg, db, vision}`;工具返回字符串,`read_file` 读图时返回
`{text, image_rel}`(由 engine 转成 `image_ref` 块)。 `{text, image_rel}`(由 engine 转成 `image_ref` 块)。
@@ -166,9 +172,17 @@ POST /api/sessions/:id/messages
`source_path`,且只限同一用户的会话。写侧显式拒绝——否则会造出字面 `@task-x` 目录。 `source_path`,且只限同一用户的会话。写侧显式拒绝——否则会造出字面 `@task-x` 目录。
- `checkToolArgs` + `unwrapToolArgs`:前者做结构性预检并生成 `errAck`,后者按 schema 逐层剥掉 - `checkToolArgs` + `unwrapToolArgs`:前者做结构性预检并生成 `errAck`,后者按 schema 逐层剥掉
弱模型多包的信封。两者都是纯函数并已导出,便于回归验证。 弱模型多包的信封。两者都是纯函数并已导出,便于回归验证。
- 技能(`tools/skills.js`):`SKILL.md` front matter 提供 `description`/`input_schema`; - 技能(`tools/skills.js`):`SKILL.md` front matter 提供 `description`/`input_schema`。
`input_schema.required` 在 `run` 前校验;相对路径参数按会话目录转绝对路径;入口一律用绝对路径 工具参数是「动词作键」:`{"list":"all"}` / `{"get":"<名>"}` / `{"run":"<名>","args":{...}}`,
(远端 cwd 是会话目录)。配了 executor 就走 `remote-exec`,否则本地 `spawn`。 三者恰好给一个(无法用 `required` 表达,校验在 `toolSkill` 里做)。`input_schema.required` 在
`run` 前校验;相对路径参数按会话目录转绝对路径;入口一律用绝对路径(远端 cwd 是会话目录)。
配了 executor 就走 `remote-exec`,否则本地 `spawn`。旧形状 `{op, name, input_args}` 仅由
`toolSkill` 兜底翻译(存量技能文档里还写着它),不再对外文档化。
模型可见的技能清单是 `listCallableSkills`(目录技能 + `mode=skill` 的 MCP 工具,同名时目录胜出);
设置页的技能 API 仍只用 `listSkills`(按目录增删改),两者不要混用。
mode=skill 的 MCP 技能在 `runSkill` 里位于 `absolutizeArgs` **之前**:直接 `mcp.callTool` 转发
(不落沙箱,也不需要密钥),因此 URL 与含 `/` 的 prompt 不会被当路径改写;同样不跑
`input_schema.required` 校验(参数与 MCP 工具自己的 `op` 相关,交给服务管)。
- MCP(`mcp.js`):启动时 `initialize` → `notifications/initialized` → `tools/list`;与内置或已有 - MCP(`mcp.js`):启动时 `initialize` → `notifications/initialized` → `tools/list`;与内置或已有
MCP 工具重名时加 `<服务名>__` 前缀;请求随带 `X-Session-Dir`、`X-Public-Base`; MCP 工具重名时加 `<服务名>__` 前缀;请求随带 `X-Session-Dir`、`X-Public-Base`;
`content` 里的 `ui_card` 块不进模型上下文,转成 SSE `ui_card` 事件。 `content` 里的 `ui_card` 块不进模型上下文,转成 SSE `ui_card` 事件。
+3 -1
View File
@@ -78,7 +78,9 @@ auth: # users 留空 = 不启用登
role: admin # admin=管理员(全部设置 + 用户管理);user 或缺省=普通用户(仅账户页) role: admin # admin=管理员(全部设置 + 用户管理);user 或缺省=普通用户(仅账户页)
# model: qwen-tp/qwen3.8-flash # 选填:该用户新建会话时锁定的模型(内部键「平台名/模型id」) # model: qwen-tp/qwen3.8-flash # 选填:该用户新建会话时锁定的模型(内部键「平台名/模型id」)
# MCP 服务列表(仓库自带的 mcp/ 三个服务,或栈外服务):每项 {name?, url, headers?, enable?(默认 true), timeout_ms?, tools_allow?, tools_deny?}。 # MCP 服务列表(仓库自带的 mcp/ 三个服务,或栈外服务):每项 {name?, url, headers?, mode?(默认 advertise), timeout_ms?, tools_allow?, tools_deny?}。
# mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始 input_schema,run 转发);
# disable=不连接、不发现。旧字段 enable 已废弃;mode: silent 已移除(改用 skill),写进配置会启动报错。
mcp_servers: [] mcp_servers: []
public_link: public_link:
+15 -4
View File
@@ -121,7 +121,9 @@ const DEFAULTS = {
}, },
// 登录认证:{users:[{user,password}], secret?, ttl_ms?};null / users 空 = 不启用。 // 登录认证:{users:[{user,password}], secret?, ttl_ms?};null / users 空 = 不启用。
auth: null, auth: null,
// 外部 MCP 服务列表(无默认值):{name?, url, headers?, enable?(默认 true), timeout_ms?(默认 60s)}。 // 外部 MCP 服务列表(无默认值):{name?, url, headers?, mode?(默认 advertise), timeout_ms?(默认 60s)}。
// mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始
// input_schema,run 直接转发);disable=不加载。
mcp_servers: [], mcp_servers: [],
// 公网临时链接:base_url 非空才启用 mint_public_link;容器配 VIRTUAL_HOST 时以它为准。 // 公网临时链接:base_url 非空才启用 mint_public_link;容器配 VIRTUAL_HOST 时以它为准。
public_link: { base_url: '', ttl_ms: 1800000 }, public_link: { base_url: '', ttl_ms: 1800000 },
@@ -340,7 +342,7 @@ function parseAndValidate(rawText, configPath) {
} }
// MCP 服务规范化:url 必填;name 缺省取主机名首段;headers 为普通键值对象(如 Authorization); // MCP 服务规范化:url 必填;name 缺省取主机名首段;headers 为普通键值对象(如 Authorization);
// enable 缺省 true,显式 false 时启动不加载该服务的工具(见 mcp.init); // mode 缺省 advertise,见下方三态校验(工具是否下发 / 是否加载,见 mcp.init);
// timeout_ms 为该服务单次 tools/call 的最大等待,缺省 60s(长任务服务如视频生成可调大)。 // timeout_ms 为该服务单次 tools/call 的最大等待,缺省 60s(长任务服务如视频生成可调大)。
if (!Array.isArray(cfg.mcp_servers)) cfg.mcp_servers = []; if (!Array.isArray(cfg.mcp_servers)) cfg.mcp_servers = [];
for (const s of cfg.mcp_servers) { for (const s of cfg.mcp_servers) {
@@ -348,8 +350,17 @@ function parseAndValidate(rawText, configPath) {
if (!s.name) { if (!s.name) {
try { s.name = String(new URL(s.url).hostname.split('.')[0]); } catch (_) { s.name = 'mcp'; } try { s.name = String(new URL(s.url).hostname.split('.')[0]); } catch (_) { s.name = 'mcp'; }
} }
// 容错 YAML 里写成字符串 "false" / "off" 的情况,统一归一为布尔 // 旧字段 enable 已废弃且不静默忽略:未知键会被无声丢弃,那样「以为关了」的服务会照常连上、
s.enable = !(s.enable === false || s.enable === 'false' || s.enable === 'off' || s.enable === 0); // 照常烧额度。宁可启动即报错,把迁移动作逼到明面上。
if (s.enable !== undefined) {
throw new Error('mcp_servers 的 enable 已废弃,请改用 mode: advertise | skill | disable');
}
// 三态:advertise(默认,工具下发给模型)/ skill(不下发,改为以技能形式暴露)/
// disable(不连接、不发现)。拼错要报错而不是回落默认,否则又是一次静默降级。
const mode = String(s.mode == null ? '' : s.mode).trim().toLowerCase();
if (!mode) s.mode = 'advertise';
else if (mode === 'advertise' || mode === 'skill' || mode === 'disable') s.mode = mode;
else throw new Error('mcp_servers 的 mode 只能是 advertise / skill / disable,收到:' + mode);
const headers = {}; const headers = {};
for (const [k, v] of Object.entries(s.headers || {})) headers[k] = String(v); for (const [k, v] of Object.entries(s.headers || {})) headers[k] = String(v);
s.headers = headers; s.headers = headers;
+24 -4
View File
@@ -2,6 +2,7 @@
const Database = require('better-sqlite3'); const Database = require('better-sqlite3');
const path = require('path'); const path = require('path');
const fs = require('fs'); const fs = require('fs');
const { dayString } = require('./time');
function initDb(dbPath) { function initDb(dbPath) {
fs.mkdirSync(path.dirname(dbPath), { recursive: true }); fs.mkdirSync(path.dirname(dbPath), { recursive: true });
@@ -116,7 +117,7 @@ function initDb(dbPath) {
); );
-- 长期记忆(日记,memory.js):一片碎片一行——会话收口(下班)时落库,(user, session_id) 主键即去重。 -- 长期记忆(日记,memory.js):一片碎片一行——会话收口(下班)时落库,(user, session_id) 主键即去重。
-- day = 事件日(会话最后活跃日,Asia/Shanghai 与 cron 同时区):人回忆问「哪天干的活」,不是「哪天补记的」。 -- day = 事件日(上海时区,time.js 固定,与 cron 同源):由 last_active_at 派生;人回忆问「哪天干的活」,不是「哪天补记的」。
-- text = 纯日记正文(- 行列表);来源会话 id 存在 session_id 列,【id】展示样式只在渲染层拼,存储零冗余。 -- text = 纯日记正文(- 行列表);来源会话 id 存在 session_id 列,【id】展示样式只在渲染层拼,存储零冗余。
-- 故意不建外键:主键是 (user, session_id),SQLite 要求引用列命中唯一约束,单列 session_id -- 故意不建外键:主键是 (user, session_id),SQLite 要求引用列命中唯一约束,单列 session_id
-- 建不了 FK;且删会话的连带清理由 engine.deleteSession 显式 memory.dropFragment 承担 -- 建不了 FK;且删会话的连带清理由 engine.deleteSession 显式 memory.dropFragment 承担
@@ -127,7 +128,8 @@ function initDb(dbPath) {
session_id TEXT NOT NULL, session_id TEXT NOT NULL,
day TEXT NOT NULL, -- 'YYYY-MM-DD'(事件日) day TEXT NOT NULL, -- 'YYYY-MM-DD'(事件日)
text TEXT NOT NULL, text TEXT NOT NULL,
created_at INTEGER NOT NULL, -- 收口时刻(注入/检索的时序键) created_at INTEGER NOT NULL, -- 收口时刻(写入/迁移时间,不当作事件时刻)
last_active_at INTEGER, -- 最后一条真实 user/assistant 消息的时刻(收口时快照;存量回填可为 NULL)
PRIMARY KEY (user, session_id) PRIMARY KEY (user, session_id)
); );
@@ -265,7 +267,6 @@ function initDb(dbPath) {
// 搬完即 drop;解析不出【sid】头的块(DAY_MAX 时代削出的孤儿残句)直接丢弃; // 搬完即 drop;解析不出【sid】头的块(DAY_MAX 时代削出的孤儿残句)直接丢弃;
// 存量碎片的 day 顺手改判为来源会话最后活跃日(事件日语义修正,积压补记自然散布回真实日期)。 // 存量碎片的 day 顺手改判为来源会话最后活跃日(事件日语义修正,积压补记自然散布回真实日期)。
if (db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='memory_entries'").get()) { if (db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='memory_entries'").get()) {
const dayFmt = new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Shanghai' });
const mf = db.prepare('INSERT OR IGNORE INTO memory_fragments (user, session_id, day, text, created_at) VALUES (?,?,?,?,?)'); const mf = db.prepare('INSERT OR IGNORE INTO memory_fragments (user, session_id, day, text, created_at) VALUES (?,?,?,?,?)');
const getUpd = db.prepare('SELECT updated_at FROM sessions WHERE id = ?'); const getUpd = db.prepare('SELECT updated_at FROM sessions WHERE id = ?');
for (const r of db.prepare('SELECT user, day, content, updated_at FROM memory_entries').all()) { for (const r of db.prepare('SELECT user, day, content, updated_at FROM memory_entries').all()) {
@@ -275,7 +276,7 @@ function initDb(dbPath) {
const sidM = /task-[0-9A-Za-z_-]+/.exec(m[1]); // 兼容三代头格式:【标题 · sid】/【sid】 const sidM = /task-[0-9A-Za-z_-]+/.exec(m[1]); // 兼容三代头格式:【标题 · sid】/【sid】
if (!sidM) continue; if (!sidM) continue;
const srow = getUpd.get(sidM[0]); const srow = getUpd.get(sidM[0]);
mf.run(r.user, sidM[0], srow && srow.updated_at ? dayFmt.format(new Date(srow.updated_at)) : r.day, m[2].trim(), r.updated_at || Date.now()); mf.run(r.user, sidM[0], srow && srow.updated_at ? dayString(srow.updated_at) : r.day, m[2].trim(), r.updated_at || Date.now());
} }
} }
db.exec('DROP TABLE memory_entries'); db.exec('DROP TABLE memory_entries');
@@ -287,6 +288,25 @@ function initDb(dbPath) {
'DELETE FROM memory_fragments WHERE session_id NOT IN (SELECT id FROM sessions)' 'DELETE FROM memory_fragments WHERE session_id NOT IN (SELECT id FROM sessions)'
).run().changes || 0; ).run().changes || 0;
if (orphan) console.log('[db] 清理孤儿日记碎片 ' + orphan + ' 条(来源会话已删除)'); if (orphan) console.log('[db] 清理孤儿日记碎片 ' + orphan + ' 条(来源会话已删除)');
// 迁移:日记碎片补 last_active_at(最后真实对话时刻)。created_at 是收口/迁移时间,不能当事件时刻;
// 存量行按「最后真实消息 → updated_at → created_at」找第一个上海日期等于 day 的候选,找不到就留 NULL
//(渲染时只显示日期)。放在 memory_entries 迁移之后,刚搬过来的行也能一起回填。
try { db.exec('ALTER TABLE memory_fragments ADD COLUMN last_active_at INTEGER'); } catch (_) { /* 已存在 */ }
const needStamp = db.prepare('SELECT 1 FROM memory_fragments WHERE last_active_at IS NULL LIMIT 1').get();
if (needStamp) {
const lastMsg = db.prepare(
"SELECT MAX(created_at) AS m FROM messages WHERE session_id = ? AND type IS NULL AND role IN ('user','assistant')"
);
const getUpdated = db.prepare('SELECT updated_at FROM sessions WHERE id = ?');
const setStamp = db.prepare('UPDATE memory_fragments SET last_active_at = ? WHERE user = ? AND session_id = ?');
for (const f of db.prepare('SELECT user, session_id, day, created_at FROM memory_fragments WHERE last_active_at IS NULL').all()) {
const m = lastMsg.get(f.session_id);
const s = getUpdated.get(f.session_id);
const cands = [m && m.m, s && s.updated_at, f.created_at].filter(Boolean).map(Number);
const pick = cands.find(ms => dayString(ms) === f.day);
if (pick) setStamp.run(pick, f.user, f.session_id);
}
}
return db; return db;
} }
+17 -5
View File
@@ -1198,7 +1198,7 @@ function maybeAutoCompress(sessionId, run, wasCompressTurn) {
// ---------- 长期记忆碎片(日记):会话收口(下班)时为其生成一条事件碎片 ---------- // ---------- 长期记忆碎片(日记):会话收口(下班)时为其生成一条事件碎片 ----------
// 与自动标题同模式:fire-and-forget + 内存防重入;绝不阻塞轮换路径(微信先回信, // 与自动标题同模式:fire-and-forget + 内存防重入;绝不阻塞轮换路径(微信先回信,
// 日记后台慢慢落)。一片一行入 memory_fragments,day=事件日(会话最后活跃日), // 日记后台慢慢落)。一片一行入 memory_fragments,day 由最后真实对话时刻(last_active_at)派生,
// 去重靠 (user, session_id) 主键;渲染/检索全在 memory.js。 // 去重靠 (user, session_id) 主键;渲染/检索全在 memory.js。
// /clear 不记也不留:用户主动清零历史 = 不要这段记忆(已定调),旧碎片随清空一并撕掉(闹钟专柜除外,见 clearSessionMessages)。 // /clear 不记也不留:用户主动清零历史 = 不要这段记忆(已定调),旧碎片随清空一并撕掉(闹钟专柜除外,见 clearSessionMessages)。
// 摘要模型走候选链兜底(用户定调:日记错过即丢,不能死于会话原绑模型这一个单点): // 摘要模型走候选链兜底(用户定调:日记错过即丢,不能死于会话原绑模型这一个单点):
@@ -1274,6 +1274,15 @@ function journalCandidateModels(s) {
return cands; return cands;
} }
// 最后真实对话时刻(毫秒):注入/归档/摘要/工具回执都不算;没有对话时退回会话 updated_at。
// 这是日记的「事件时刻」,不可用 created_at(收口/迁移时间)替代。
function lastActiveAtOf(sessionId, fallback) {
const r = db.prepare(
"SELECT MAX(created_at) AS m FROM messages WHERE session_id = ? AND type IS NULL AND role IN ('user','assistant')"
).get(String(sessionId));
return (r && r.m) || Number(fallback) || now();
}
// 生成并落库一个会话的日记碎片;返回 Promise<boolean>(是否写入)。调用方不需要等它。 // 生成并落库一个会话的日记碎片;返回 Promise<boolean>(是否写入)。调用方不需要等它。
function journalFragment(sessionId) { function journalFragment(sessionId) {
return new Promise(resolve => { return new Promise(resolve => {
@@ -1283,12 +1292,14 @@ function journalFragment(sessionId) {
if (journaling.has(sessionId)) return done(false); if (journaling.has(sessionId)) return done(false);
const s = getSession(sessionId); const s = getSession(sessionId);
if (!s || s.journaled_at) return done(false); // 已收口的会话不二次碎片(每会话唯一碎片的入口保证) if (!s || s.journaled_at) return done(false); // 已收口的会话不二次碎片(每会话唯一碎片的入口保证)
const day = memory.dayString(s.updated_at || now()); // 事件日=会话最后活跃日(C 定稿):人回忆问哪天干的活,不是哪天补记 // 事件时刻取最后一条真实对话消息;没有对话再退回 updated_at。day 与它同源,避免日期/时刻互相打架。
const lastActiveAt = lastActiveAtOf(sessionId, s.updated_at);
const day = memory.dayString(lastActiveAt);
// 无论成败都落一条:降级版写明真实原因(调试页可见);来源会话 id 是表列,正文零元数据。 // 无论成败都落一条:降级版写明真实原因(调试页可见);来源会话 id 是表列,正文零元数据。
const finish = (body, reason) => { const finish = (body, reason) => {
journaling.delete(sessionId); journaling.delete(sessionId);
const r = memory.appendFragment(db, cfg, s.user, s.id, day, const r = memory.appendFragment(db, cfg, s.user, s.id, day,
body || '- 本次工作未能生成摘要(' + (reason || '原因未知') + '),详情可按会话 id 回忆'); body || '- 本次工作未能生成摘要(' + (reason || '原因未知') + '),详情可按会话 id 回忆', lastActiveAt);
if (r === 'added' || r === 'dupe') memory.markJournaled(db, sessionId, now()); // dupe 也算收口,不重试 if (r === 'added' || r === 'dupe') memory.markJournaled(db, sessionId, now()); // dupe 也算收口,不重试
return r === 'added' || r === 'dupe'; return r === 'added' || r === 'dupe';
}; };
@@ -1337,8 +1348,9 @@ function taskClockOut(sessionId) {
const t = db.prepare('SELECT cron_expr, prompt, brief FROM scheduled_tasks WHERE session_id = ?').get(sessionId); const t = db.prepare('SELECT cron_expr, prompt, brief FROM scheduled_tasks WHERE session_id = ?').get(sessionId);
if (!t) return; if (!t) return;
const what = String(t.brief || t.prompt || '').replace(/\s+/g, ' ').trim().slice(0, 80); const what = String(t.brief || t.prompt || '').replace(/\s+/g, ' ').trim().slice(0, 80);
const r = memory.appendFragment(db, cfg, s.user, s.id, memory.dayString(s.updated_at || now()), const lastActiveAt = lastActiveAtOf(sessionId, s.updated_at);
'- 用户让我设了个闹钟:' + what + '(频率 ' + t.cron_expr + ')'); const r = memory.appendFragment(db, cfg, s.user, s.id, memory.dayString(lastActiveAt),
'- 用户让我设了个闹钟:' + what + '(频率 ' + t.cron_expr + ')', lastActiveAt);
if (r === 'added' || r === 'dupe') memory.markJournaled(db, sessionId, now()); if (r === 'added' || r === 'dupe') memory.markJournaled(db, sessionId, now());
if (s.status === 'held') { try { releaseHold(sessionId); } catch (_) { /* 并发归档 */ } } if (s.status === 'held') { try { releaseHold(sessionId); } catch (_) { /* 并发归档 */ } }
const un = db.prepare('DELETE FROM channel_sessions WHERE session_id = ?').run(sessionId); const un = db.prepare('DELETE FROM channel_sessions WHERE session_id = ?').run(sessionId);
+37 -13
View File
@@ -1,8 +1,10 @@
// 极简 MCP 客户端(Streamable HTTP:JSON-RPC over HTTP,无状态,响应可能是 SSE 帧包裹的 JSON)。 // 极简 MCP 客户端(Streamable HTTP:JSON-RPC over HTTP,无状态,响应可能是 SSE 帧包裹的 JSON)。
// MCP 服务在 config.yml 的 mcp_servers 中配置(可多个):{name?, url, headers?, enable?, timeout_ms?, tools_allow?, tools_deny?}。 // MCP 服务在 config.yml 的 mcp_servers 中配置(可多个):{name?, url, headers?, mode?, timeout_ms?, tools_allow?, tools_deny?}。
// 启动时 init() 对每个服务调 tools/list 发现工具(enable: false 的服务跳过加载;配了 tools_allow/tools_deny // 启动时 init() 对每个服务调 tools/list 发现工具(mode: disable 的服务跳过加载;配了 tools_allow/tools_deny
// 时按名单过滤),发现失败的服务按 2s / 20s / 1min 再试 3 次(容器并行启动/重启后的乱序兜底),转成 OpenAI function 格式, // 时按名单过滤),发现失败的服务按 2s / 20s / 1min 再试 3 次(容器并行启动/重启后的乱序兜底),转成 OpenAI function 格式,
// 追加在内置工具(definitions.json)之后一起随 system prompt 发给模型; // 追加在内置工具(definitions.json)之后一起随 system prompt 发给模型;
// mode: skill 的服务工具照常注册进 toolIndex(lab 可调),不追加进
// toolDefs,而是由 tools/skills.js 自动包装成技能(get 返回注册表里的原始 input_schema)。
// 工具调用经 tools/call 转发给对应服务。 // 工具调用经 tools/call 转发给对应服务。
// 与内置工具严格分离:本模块不碰内置定义;MCP 工具默认沿用原始名, // 与内置工具严格分离:本模块不碰内置定义;MCP 工具默认沿用原始名,
// 仅当与内置工具或其他 MCP 工具重名时加「服务名__」前缀。 // 仅当与内置工具或其他 MCP 工具重名时加「服务名__」前缀。
@@ -14,7 +16,7 @@ const log = require('./log');
const CALL_TIMEOUT_MS = 60000; const CALL_TIMEOUT_MS = 60000;
let toolDefs = []; // OpenAI function 格式(所有 MCP 工具) let toolDefs = []; // OpenAI function 格式(所有 MCP 工具)
const toolIndex = new Map(); // 发送名 -> { server, tool }(服务配置 + 原始工具名) const toolIndex = new Map(); // 发送名 -> { server, tool, def }(服务配置 + 原始工具名 + 原始契约)
let builtinNames = new Set(); let builtinNames = new Set();
let PUBLIC_BASE = ''; // core 自身公网前缀(loadConfig 已归一:VIRTUAL_HOST 优先 config.yml);随每次请求 X-Public-Base 头下发 let PUBLIC_BASE = ''; // core 自身公网前缀(loadConfig 已归一:VIRTUAL_HOST 优先 config.yml);随每次请求 X-Public-Base 头下发
@@ -141,22 +143,25 @@ async function loadServer(s) {
let tools = all; let tools = all;
if (Array.isArray(s.tools_allow)) tools = tools.filter(t => s.tools_allow.includes(t && t.name)); if (Array.isArray(s.tools_allow)) tools = tools.filter(t => s.tools_allow.includes(t && t.name));
if (Array.isArray(s.tools_deny)) tools = tools.filter(t => !s.tools_deny.includes(t && t.name)); if (Array.isArray(s.tools_deny)) tools = tools.filter(t => !s.tools_deny.includes(t && t.name));
let hidden = 0;
for (const t of tools) { for (const t of tools) {
if (!t || !t.name) continue; if (!t || !t.name) continue;
let name = t.name; let name = t.name;
if (builtinNames.has(name) || toolIndex.has(name)) name = s.name + '__' + name; if (builtinNames.has(name) || toolIndex.has(name)) name = s.name + '__' + name;
toolIndex.set(name, { server: s, tool: t.name }); // 先进索引:mode=skill 的工具同样要能被 lab 调到,只是不下发。
toolDefs.push({ // 索引里连规范化后的契约一起留住,技能 get 时原样返回(单一份真相,不会跟 MCP 实现漂移)。
type: 'function', const def = {
function: {
name, name,
description: t.description || t.title || '', description: t.description || t.title || '',
parameters: t.inputSchema || t.input_schema || { type: 'object', properties: {} }, parameters: t.inputSchema || t.input_schema || { type: 'object', properties: {} },
}, };
}); toolIndex.set(name, { server: s, tool: t.name, def });
if (s.mode === 'skill') { hidden++; continue; }
toolDefs.push({ type: 'function', function: def });
} }
let msg = s.name + ': 发现 ' + tools.length + ' 个工具' + (s.sessionId ? ' (session)' : ''); let msg = s.name + ': 发现 ' + tools.length + ' 个工具' + (s.sessionId ? ' (session)' : '');
if (tools.length !== all.length) msg += '(服务端共 ' + all.length + ' 个,已按 tools_allow/tools_deny 过滤)'; if (tools.length !== all.length) msg += '(服务端共 ' + all.length + ' 个,已按 tools_allow/tools_deny 过滤)';
if (hidden) msg += '(mode=skill:' + hidden + ' 个以技能形式暴露,不下发给模型)';
log.info('mcp', msg); log.info('mcp', msg);
// 配了名单却一个都没过滤中,十有八九是名单里的名字跟 tools/list 返回不一致; // 配了名单却一个都没过滤中,十有八九是名单里的名字跟 tools/list 返回不一致;
// 不 warn 的话排查时只能对着「发现 0 个工具」干瞪眼。 // 不 warn 的话排查时只能对着「发现 0 个工具」干瞪眼。
@@ -213,9 +218,9 @@ async function init(cfg) {
const servers = (cfg && cfg.mcp_servers) || []; const servers = (cfg && cfg.mcp_servers) || [];
const failed = []; const failed = [];
for (const s of servers) { for (const s of servers) {
// enable: false 时启动不加载该服务(不建工具表;配置保留,改回 true 重启后恢复) // mode: disable 时启动不加载该服务(不建工具表;配置保留,改回 advertise 重启后恢复)
if (s.enable === false) { if (s.mode === 'disable') {
log.info('mcp', s.name + ': enable=false,跳过工具加载'); log.info('mcp', s.name + ': mode=disable,跳过工具加载');
continue; continue;
} }
if (!(await loadServer(s))) failed.push(s); if (!(await loadServer(s))) failed.push(s);
@@ -228,6 +233,25 @@ function toolDefinitions() { return toolDefs; }
function hasTool(name) { return toolIndex.has(name); } function hasTool(name) { return toolIndex.has(name); }
// mode=skill 的工具:不进 tools 数组,由 skills.js 包装成技能(list/get/run)。
// 名字一律用最终可调用名(含重名时的 server__ 前缀),否则模型拿到的是调不通的名字。
function skillTools() {
const out = [];
for (const [name, e] of toolIndex) {
if (!e || !e.server || e.server.mode !== 'skill' || !e.def) continue;
out.push({ name, description: e.def.description, parameters: e.def.parameters, server: e.server.name, tool: e.tool });
}
return out;
}
// 只认 mode=skill:advertise 的工具已经直接下发给模型,不必再绕技能这一层。
function getSkillTool(name) {
const key = String(name == null ? '' : name).trim();
const e = toolIndex.get(key);
if (!e || !e.server || e.server.mode !== 'skill' || !e.def) return null;
return { name: key, description: e.def.description, parameters: e.def.parameters, server: e.server.name, tool: e.tool };
}
// 把工具调用转发给对应 MCP 服务,返回给模型的文本结果。 // 把工具调用转发给对应 MCP 服务,返回给模型的文本结果。
// 超时取该服务的 timeout_ms(config.js 里归一化 + 夹过区间);这里再兜一次底, // 超时取该服务的 timeout_ms(config.js 里归一化 + 夹过区间);这里再兜一次底,
// 兼容没走配置加载的调用方(如测试里手搓的 cfg)。 // 兼容没走配置加载的调用方(如测试里手搓的 cfg)。
@@ -271,4 +295,4 @@ async function notifyTool(name, args, timeoutMs, extraHeaders) {
} }
} }
module.exports = { init, toolDefinitions, hasTool, callTool, notifyTool }; module.exports = { init, toolDefinitions, hasTool, skillTools, getSkillTool, callTool, notifyTool };
+29 -22
View File
@@ -2,16 +2,18 @@
//(碎片摘要生成在 engine.journalFragment,与自动标题同模式:fire-and-forget + 候选模型兜底链)。 //(碎片摘要生成在 engine.journalFragment,与自动标题同模式:fire-and-forget + 候选模型兜底链)。
// 与 profile(user-profile.js)分工:profile 记「用户是什么样的人」(语义记忆、稳定特质), // 与 profile(user-profile.js)分工:profile 记「用户是什么样的人」(语义记忆、稳定特质),
// 日记记「我近来帮他做过什么」(事件记忆),两类记忆互不混。 // 日记记「我近来帮他做过什么」(事件记忆),两类记忆互不混。
// 结构(C 定稿):一片碎片一行——memory_fragments(user, session_id PK, day, text, created_at)。 // 结构(C 定稿):一片碎片一行——memory_fragments(user, session_id PK, day, text, created_at, last_active_at)。
// - day = 事件日(会话最后活跃日):人回忆问的是「哪天干的活」,不是「哪天补记的」; // - day = 事件日(Asia/Shanghai),由 last_active_at 派生:人回忆问的是「哪天干的活」,不是「哪天补记的」;
// - last_active_at = 收口时快照的最后一条真实 user/assistant 消息时刻(存量数据可为 NULL);
// - text = 纯日记正文("- " 行列表),【来源会话 id】展示样式只在渲染层拼,存储零冗余元数据; // - text = 纯日记正文("- " 行列表),【来源会话 id】展示样式只在渲染层拼,存储零冗余元数据;
// - 会话标题不进回忆头部:标题是会话名,不是事件内容,容易把「回忆」带偏;
// - (user, session_id) 主键即「每会话唯一碎片」的存储级保证(engine 侧 journaled_at 是扫描预排除); // - (user, session_id) 主键即「每会话唯一碎片」的存储级保证(engine 侧 journaled_at 是扫描预排除);
// - 注入 =「嘴边的工作记忆」:开场只带最近 inject_max 片(created_at 倒序);更早的没消失—— // - 注入 =「嘴边的工作记忆」:开场只带最近 inject_max 片(day 优先、同日按 last_active_at 倒序);更早的没消失——
// recall 工具 op=search/days/day 走全表;retain_days > 0 才按 day 硬裁(默认 0 = 不按时间删, // recall 工具 op=search/days/day 走全表;retain_days > 0 才按 day 硬裁(默认 0 = 不按时间删,
// 但删会话会连带撕掉它的碎片,见 dropFragment)。 // 但删会话会连带撕掉它的碎片,见 dropFragment)。
// 时区与 cron(scheduler.js)对齐 Asia/Shanghai:上海无夏令时,按毫秒日移取 day 字符串安全。 // 业务时区统一由 time.js 固定为 Asia/Shanghai(与 cron 同源):上海无夏令时,按毫秒日移取 day 字符串安全。
const TZ = 'Asia/Shanghai'; const { dayString, stampString } = require('./time');
const INJECT_CAP = 50; // inject_max 硬帽:防配置手滑把整个日记灌进上下文 const INJECT_CAP = 50; // inject_max 硬帽:防配置手滑把整个日记灌进上下文
const FRAG_MAX = 600; // 单碎片正文长度帽 const FRAG_MAX = 600; // 单碎片正文长度帽
@@ -26,9 +28,6 @@ function injectMax(cfg) {
return Math.max(0, Math.min(INJECT_CAP, n)); return Math.max(0, Math.min(INJECT_CAP, n));
} }
const dayFmt = new Intl.DateTimeFormat('en-CA', { timeZone: TZ }); // en-CA = ISO 'YYYY-MM-DD'
function dayString(ms) { return dayFmt.format(new Date(Number(ms) || Date.now())); }
// 保留窗最旧一天的日串(retain_days=0 → 空串 = 无下界)。 // 保留窗最旧一天的日串(retain_days=0 → 空串 = 无下界)。
function cutoffDay(cfg, refMs) { function cutoffDay(cfg, refMs) {
const n = retainDays(cfg); const n = retainDays(cfg);
@@ -38,12 +37,14 @@ function cutoffDay(cfg, refMs) {
// ---------- 写:一片一行,主键即去重 ---------- // ---------- 写:一片一行,主键即去重 ----------
// 返回 'added' 新落 / 'dupe' 该会话已有碎片(主键冲突)/ 'invalid' 参数不全。 // 返回 'added' 新落 / 'dupe' 该会话已有碎片(主键冲突)/ 'invalid' 参数不全。
// 调用方(engine 收口链路)把 added/dupe 都视为已收口落 journaled 标记,不重试不重复摘要。 // 调用方(engine 收口链路)把 added/dupe 都视为已收口落 journaled 标记,不重试不重复摘要。
function appendFragment(db, cfg, user, sessionId, day, text) { function appendFragment(db, cfg, user, sessionId, day, text, lastActiveAt) {
const body = String(text || '').replace(/\r/g, '').trim().slice(0, FRAG_MAX); const body = String(text || '').replace(/\r/g, '').trim().slice(0, FRAG_MAX);
if (!sessionId || !day || !body) return 'invalid'; if (!sessionId || !day || !body) return 'invalid';
// last_active_at 是事件时刻快照;created_at 是本碎片收口/写入时间,两者不可混用。
const stamp = Number(lastActiveAt) || Date.now();
const r = db.prepare( const r = db.prepare(
'INSERT OR IGNORE INTO memory_fragments (user, session_id, day, text, created_at) VALUES (?,?,?,?,?)' 'INSERT OR IGNORE INTO memory_fragments (user, session_id, day, text, created_at, last_active_at) VALUES (?,?,?,?,?,?)'
).run(String(user || ''), String(sessionId), day, body, Date.now()); ).run(String(user || ''), String(sessionId), day, body, Date.now(), stamp);
if (!r.changes) return 'dupe'; if (!r.changes) return 'dupe';
prune(db, cfg); // 廉价 DELETE 顺带做;retain_days=0 时 no-op prune(db, cfg); // 廉价 DELETE 顺带做;retain_days=0 时 no-op
return 'added'; return 'added';
@@ -65,28 +66,34 @@ function markJournaled(db, sessionId, ms) {
} }
// ---------- 读:开场注入文本(wechat/web 新会话的数据源) ---------- // ---------- 读:开场注入文本(wechat/web 新会话的数据源) ----------
// 最近 inject_max 片按事件日优先(同序供 injectedIds/journalFor 共用),逐片「## id,day」自描述: // 最近 inject_max 片按事件日优先(同序供 injectedIds/journalFor 共用),逐片「## id, date」自描述:
// 新日在前、天内按发生顺序。 // 新日在前、天内按发生顺序。
// 选取序单点定义在此(调试 API/页面走 injectedIds 取名单,不另算一套,避免两边错位)。 // 选取序单点定义在此(调试 API/页面走 injectedIds 取名单,不另算一套,避免两边错位)。
const INJECT_ORDER = ' ORDER BY day DESC, created_at DESC'; const INJECT_ORDER = ' ORDER BY f.day DESC, COALESCE(f.last_active_at, f.created_at) DESC';
// 读路径统一列清单:renderFrag 依赖 day/last_active_at,三处查询不再各写 SELECT,避免漏列。
const FRAG_COLS = 'f.session_id, f.day, f.text, f.last_active_at';
const FRAG_FROM = ' FROM memory_fragments f';
// 注入窗名单:与 journalFor 同选取规则的 session_id 列表(调试页打「已注入」标用)。 // 注入窗名单:与 journalFor 同选取规则的 session_id 列表(调试页打「已注入」标用)。
function injectedIds(db, cfg, user) { function injectedIds(db, cfg, user) {
const cap = injectMax(cfg); const cap = injectMax(cfg);
if (!cap) return []; if (!cap) return [];
return db.prepare( return db.prepare(
'SELECT session_id FROM memory_fragments WHERE user = ?' + INJECT_ORDER + ' LIMIT ?' 'SELECT f.session_id FROM memory_fragments f WHERE f.user = ?' + INJECT_ORDER + ' LIMIT ?'
).all(String(user || ''), cap).map(r => r.session_id); ).all(String(user || ''), cap).map(r => r.session_id);
} }
// 渲染逐片自描述:「## id=…, day=…」——新在前、天内按发生顺序;id/day 进标题即机器可读, // 渲染逐片自描述:「## id=…, date=YYYY-MM-DD HH:MM:SS」——新在前、天内按发生顺序。
// 分天组头退役。 // 旧数据没有 last_active_at 时只显示 day;不拼 title,避免会话名把回忆带偏。
function renderFrag(r) { return '## id=' + r.session_id + ', day=' + r.day + '\n' + r.text; } function renderFrag(r) {
const when = stampString(r.last_active_at) || r.day || '未知';
return '## id=' + r.session_id + ', date=' + when + '\n' + r.text;
}
function journalFor(db, cfg, user) { function journalFor(db, cfg, user) {
const cap = injectMax(cfg); const cap = injectMax(cfg);
if (!cap) return ''; if (!cap) return '';
const rows = db.prepare( const rows = db.prepare(
// 选取按事件日(积压补记/迁移会令 created_at 齐平,按收口序会拿到「最晚补记」而非「最新事件」; // 选取按事件日(积压补记/迁移会令 created_at 齐平,按收口序会拿到「最晚补记」而非「最新事件」;
// 稳态下两者等价,事件日序更符合「最近记忆」直觉),同日并列再按收口时刻。 // 稳态下两者等价,事件日序更符合「最近记忆」直觉),同日并列再按最后对话时刻。
'SELECT session_id, day, text FROM memory_fragments WHERE user = ?' + INJECT_ORDER + ' LIMIT ?' 'SELECT ' + FRAG_COLS + FRAG_FROM + ' WHERE f.user = ?' + INJECT_ORDER + ' LIMIT ?'
).all(String(user || ''), cap); ).all(String(user || ''), cap);
if (!rows.length) return ''; if (!rows.length) return '';
const groups = []; const groups = [];
@@ -116,7 +123,7 @@ function searchFragments(db, user, query, count) {
if (!toks.length) return ''; if (!toks.length) return '';
const lim = Math.max(1, Math.min(30, Number(count) || 10)); const lim = Math.max(1, Math.min(30, Number(count) || 10));
const rows = db.prepare( const rows = db.prepare(
'SELECT session_id, day, text FROM memory_fragments WHERE user = ? ORDER BY created_at DESC' 'SELECT ' + FRAG_COLS + FRAG_FROM + ' WHERE f.user = ? ORDER BY COALESCE(f.last_active_at, f.created_at) DESC'
).all(String(user || '')); ).all(String(user || ''));
const hits = []; const hits = [];
rows.forEach((r, i) => { rows.forEach((r, i) => {
@@ -128,7 +135,7 @@ function searchFragments(db, user, query, count) {
if (!hits.length) return ''; if (!hits.length) return '';
hits.sort((a, b) => b.score - a.score || a.i - b.i); hits.sort((a, b) => b.score - a.score || a.i - b.i);
const shown = hits.slice(0, lim); const shown = hits.slice(0, lim);
// 条目自带 day(renderFrag 标题),行内只留相关度不重复日期 // 条目自带 date(renderFrag 标题),行内只留相关度不重复日期
const parts = ['【日记检索】「' + String(query).trim() + '」命中 ' + hits.length + ' 条,按相关度列前 ' + shown.length + ' 条:']; const parts = ['【日记检索】「' + String(query).trim() + '」命中 ' + hits.length + ' 条,按相关度列前 ' + shown.length + ' 条:'];
for (const h of shown) parts.push('--- 匹配 ' + Math.round(h.score * 100) + '% ---\n' + renderFrag(h.r)); for (const h of shown) parts.push('--- 匹配 ' + Math.round(h.score * 100) + '% ---\n' + renderFrag(h.r));
return parts.join('\n\n'); return parts.join('\n\n');
@@ -142,7 +149,7 @@ function daysIndex(db, user) {
} }
function dayEntry(db, user, date) { function dayEntry(db, user, date) {
return db.prepare( return db.prepare(
'SELECT session_id, text FROM memory_fragments WHERE user = ? AND day = ? ORDER BY created_at' 'SELECT ' + FRAG_COLS + FRAG_FROM + ' WHERE f.user = ? AND f.day = ? ORDER BY COALESCE(f.last_active_at, f.created_at)'
).all(String(user || ''), String(date || '').trim()).map(renderFrag).join('\n\n'); ).all(String(user || ''), String(date || '').trim()).map(renderFrag).join('\n\n');
} }
+2
View File
@@ -1098,6 +1098,8 @@ label.icon-btn { cursor: pointer; }
.modal .mpe-num { display: flex; align-items: center; gap: 5px; flex: none; font-size: 12.5px; color: var(--gray); } .modal .mpe-num { display: flex; align-items: center; gap: 5px; flex: none; font-size: 12.5px; color: var(--gray); }
.modal .mpe-num input { width: 92px; padding: 5px 8px; margin: 0; font-size: 13px; border: 1px solid #dde1ea; border-radius: 8px; background: #fff; color: var(--ink); } .modal .mpe-num input { width: 92px; padding: 5px 8px; margin: 0; font-size: 13px; border: 1px solid #dde1ea; border-radius: 8px; background: #fff; color: var(--ink); }
.modal .mpe-num input:focus { border-color: var(--active); } .modal .mpe-num input:focus { border-color: var(--active); }
/* MCP 的 mode 三态下拉:独立成行(弹窗内容宽仅 ~320px,与超时框同排会撑破),内层 select 用 .modal select 的全宽样式 */
.modal .mpe-field { display: block; margin-top: 14px; font-size: 12.5px; color: var(--gray); }
.modal .mpe-ck { display: flex; align-items: center; gap: 5px; font-size: 12.5px; color: var(--gray); } .modal .mpe-ck { display: flex; align-items: center; gap: 5px; font-size: 12.5px; color: var(--gray); }
.modal .mpe-ck input { width: 15px; height: 15px; padding: 0; margin: 0; border: none; background: none; accent-color: var(--active); cursor: pointer; } .modal .mpe-ck input { width: 15px; height: 15px; padding: 0; margin: 0; border: none; background: none; accent-color: var(--active); cursor: pointer; }
.modal .mpe-del { flex: none; border: none; background: none; margin: 0; padding: 2px 7px; cursor: pointer; color: var(--gray-light); font-size: 18px; line-height: 1.2; } .modal .mpe-del { flex: none; border: none; background: none; margin: 0; padding: 2px 7px; cursor: pointer; color: var(--gray-light); font-size: 18px; line-height: 1.2; }
+7 -1
View File
@@ -335,8 +335,14 @@
</div> </div>
<div class="mpe-cks" style="margin-top:14px"> <div class="mpe-cks" style="margin-top:14px">
<label class="mpe-num">单次调用超时<input type="number" id="mce-timeout" min="1000" max="600000" step="1000" placeholder="默认 60000">ms</label> <label class="mpe-num">单次调用超时<input type="number" id="mce-timeout" min="1000" max="600000" step="1000" placeholder="默认 60000">ms</label>
<label class="mpe-ck"><input type="checkbox" id="mce-enable" checked>启用</label>
</div> </div>
<label class="mpe-field">工具暴露
<select id="mce-mode">
<option value="advertise">advertise(下发给模型)</option>
<option value="skill">skill(以技能形式暴露)</option>
<option value="disable">disable(不加载)</option>
</select>
</label>
<div class="btn-row mpe-foot"> <div class="btn-row mpe-foot">
<button class="ghost-btn danger hidden" id="mce-del-btn" onclick="mcpUI.del()">删除服务</button> <button class="ghost-btn danger hidden" id="mce-del-btn" onclick="mcpUI.del()">删除服务</button>
<button class="primary-btn" onclick="mcpUI.save()">保存</button> <button class="primary-btn" onclick="mcpUI.save()">保存</button>
+10 -2
View File
@@ -182,6 +182,10 @@ async function openFilePreview(name, sizeText) {
try { try {
if (!desk) { await pvRenderLegacy(name, r, my); return; } if (!desk) { await pvRenderLegacy(name, r, my); return; }
let node = null, tb = { refresh: false, popup: false }; let node = null, tb = { refresh: false, popup: false };
// blob URL 不能在此登记到 pvState:show() 内部先调 pvClearBody(),那会把"刚建的"这个也一并撤销,
// 于是 img/iframe 真正去取时 URL 已失效(Chrome 报 net::ERR_FILE_NOT_FOUND;Safari 撤回更宽松才没暴露)。
// 统一等 show() 之后登记,陈旧序号则立即撤销防泄漏。
let newBlobUrl = null;
if (kind === 'html') { if (kind === 'html') {
const fr = document.createElement('iframe'); const fr = document.createElement('iframe');
fr.className = 'pv-frame'; fr.className = 'pv-frame';
@@ -190,13 +194,13 @@ async function openFilePreview(name, sizeText) {
node = fr; node = fr;
} else if (kind === 'pdf') { } else if (kind === 'pdf') {
const u = URL.createObjectURL(await r.blob()); const u = URL.createObjectURL(await r.blob());
pvState.blobUrl = u; pvState.url = u; newBlobUrl = u;
const fr = document.createElement('iframe'); const fr = document.createElement('iframe');
fr.className = 'pv-frame'; fr.title = String(name); fr.src = u; // 不加 sandbox:内建查看器插件需要 unrestricted 帧 fr.className = 'pv-frame'; fr.title = String(name); fr.src = u; // 不加 sandbox:内建查看器插件需要 unrestricted 帧
node = fr; tb = { refresh: false, popup: true }; node = fr; tb = { refresh: false, popup: true };
} else if (kind === 'img') { } else if (kind === 'img') {
const u = URL.createObjectURL(await r.blob()); const u = URL.createObjectURL(await r.blob());
pvState.blobUrl = u; pvState.url = u; newBlobUrl = u;
const im = document.createElement('img'); const im = document.createElement('img');
im.className = 'pv-img'; im.src = u; im.alt = String(name); im.className = 'pv-img'; im.src = u; im.alt = String(name);
im.addEventListener('click', () => openImageViewer(u, String(name).split('/').pop())); im.addEventListener('click', () => openImageViewer(u, String(name).split('/').pop()));
@@ -206,6 +210,10 @@ async function openFilePreview(name, sizeText) {
if (node.__tb) { tb = node.__tb; delete node.__tb; } if (node.__tb) { tb = node.__tb; delete node.__tb; }
} }
show(node, tb); show(node, tb);
if (newBlobUrl) {
if (my === pvSeq) pvState.blobUrl = pvState.url = newBlobUrl;
else { try { URL.revokeObjectURL(newBlobUrl); } catch (_) {} }
}
} catch (e) { } catch (e) {
if (my === pvSeq) desk ? show(pvInfoNode(name, sizeText, '预览失败:' + e.message), { refresh: false, popup: false }) : toast('预览失败:' + e.message); if (my === pvSeq) desk ? show(pvInfoNode(name, sizeText, '预览失败:' + e.message), { refresh: false, popup: false }) : toast('预览失败:' + e.message);
} }
+20 -11
View File
@@ -840,7 +840,7 @@
'<div class="session-main">' + '<div class="session-main">' +
'<div class="session-name">' + esc(s.name) + '<div class="session-name">' + esc(s.name) +
(s.has_md ? '' : ' <span class="badge cancelled">缺 SKILL.md</span>') + (s.has_md ? '' : ' <span class="badge cancelled">缺 SKILL.md</span>') +
(s.entry ? ' <span class="badge active">' + s.entry + ' 入口</span>' : '') + (s.entry ? ' <span class="badge active">' + (s.entry === 'mcp' ? 'mcp 后端' : s.entry + ' 入口') + '</span>' : '') +
'</div>' + '</div>' +
'<div class="skill-desc">' + esc(s.description || '') + '</div>' + '<div class="skill-desc">' + esc(s.description || '') + '</div>' +
'<div class="session-meta"><span>' + s.file_count + ' 个文件</span>' + '<div class="session-meta"><span>' + s.file_count + ' 个文件</span>' +
@@ -1416,11 +1416,13 @@
} catch (e) { toast('删除失败:' + e.message); } } catch (e) { toast('删除失败:' + e.message); }
} }
// ---------- 页:MCP 服务(增/改/删;name / url / 多 headers / timeout_ms / enable) ---------- // ---------- 页:MCP 服务(增/改/删;name / url / 多 headers / timeout_ms / mode) ----------
// 与模型池共用 PATCH /api/config 的细粒度 edit 接口: // 与模型池共用 PATCH /api/config 的细粒度 edit 接口:
// · 新增 = append 到 mcp_servers; // · 新增 = append 到 mcp_servers;
// · 删 = delete mcp_servers[pi]; // · 删 = delete mcp_servers[pi];
// · 改 = setIn mcp_servers[pi].(name|url|timeout_ms|enable);headers 是普通键值对象,整体 setIn 一次到位。 // · 改 = setIn mcp_servers[pi].(name|url|timeout_ms|mode);headers 是普通键值对象,整体 setIn 一次到位。
// mode 三态:advertise(默认,工具下发给模型) / skill(不下发,以技能形式暴露) / disable(不加载):
// 默认值不写进文件——选 advertise 时删键,回落到 config.js 的缺省。
// 运行配置(cg.effective.mcp_servers)即文件刚解析后的视图,按 pi 直接定位;重启后才会重新发现工具。 // 运行配置(cg.effective.mcp_servers)即文件刚解析后的视图,按 pi 直接定位;重启后才会重新发现工具。
let mcpEdit = null; // 工作态:{ idx, headers:[{key, value, masked}] };idx=-1 为新增 let mcpEdit = null; // 工作态:{ idx, headers:[{key, value, masked}] };idx=-1 为新增
const MCP_HEADER_MASK = '*****'; // 与后端 routes/config.js 的掩码保持一致 const MCP_HEADER_MASK = '*****'; // 与后端 routes/config.js 的掩码保持一致
@@ -1449,16 +1451,20 @@
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>' ? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>'
: ''; : '';
box.innerHTML = banner + SET.cfgMcp.map(mcpCardHtml).join('') + box.innerHTML = banner + SET.cfgMcp.map(mcpCardHtml).join('') +
'<div class="empty-tip">点卡片编辑 MCP 服务,启用后启动时发现其工具并追加到内置工具之后。</div>'; '<div class="empty-tip">点卡片编辑 MCP 服务。advertise 的工具启动时发现并追加到内置工具之后;skill 不下发,改为以技能形式暴露(skill 工具里 get 拿到原始 input_schema)。</div>';
} catch (e) { } catch (e) {
const b = $('mcp-list'); const b = $('mcp-list');
if (b && (!ctx || ctx())) b.innerHTML = '<div class="empty-tip">加载失败:' + esc(e.message) + '</div>'; if (b && (!ctx || ctx())) b.innerHTML = '<div class="empty-tip">加载失败:' + esc(e.message) + '</div>';
} }
} }
// MCP 卡:头部 = 名称 + url + enable 状态;体内 = headers 键值列表。整卡点击进入编辑。 // MCP 卡:头部 = 名称 + url + mode 状态;体内 = headers 键值列表。整卡点击进入编辑。
function mcpCardHtml(s, pi) { function mcpCardHtml(s, pi) {
const off = s.enable === false; const mode = s.mode || 'advertise';
const stateHtml = off ? '<span class="model-card-state off">已禁用</span>' : '<span class="model-card-state idle">启用</span>'; const stateHtml = mode === 'disable'
? '<span class="model-card-state off">已禁用</span>'
: mode === 'skill'
? '<span class="model-card-state idle">以技能暴露</span>'
: '<span class="model-card-state idle">启用</span>';
const entries = Object.entries(s.headers || {}); const entries = Object.entries(s.headers || {});
// header 值等同密码对待:后端 effective 已脱敏为固定短掩码,这里透传展示;若收到未脱敏原文也一律替换,不外显 // header 值等同密码对待:后端 effective 已脱敏为固定短掩码,这里透传展示;若收到未脱敏原文也一律替换,不外显
const maskVal = (v) => { const str = String(v == null ? '' : v); if (!str) return '--'; return str.includes('*') ? esc(str) : MCP_HEADER_MASK; }; const maskVal = (v) => { const str = String(v == null ? '' : v); if (!str) return '--'; return str.includes('*') ? esc(str) : MCP_HEADER_MASK; };
@@ -1490,7 +1496,7 @@
$('mce-url').value = add ? '' : (s.url || ''); $('mce-url').value = add ? '' : (s.url || '');
// 运行配置里的 timeout_ms 已被 config.js 填上缺省值,所以这里显示的就是当前生效值(没配则为 60000)。 // 运行配置里的 timeout_ms 已被 config.js 填上缺省值,所以这里显示的就是当前生效值(没配则为 60000)。
$('mce-timeout').value = add || s.timeout_ms == null ? '' : String(s.timeout_ms); $('mce-timeout').value = add || s.timeout_ms == null ? '' : String(s.timeout_ms);
$('mce-enable').checked = add ? true : (s.enable !== false); $('mce-mode').value = add ? 'advertise' : (s.mode || 'advertise');
$('mce-del-btn').classList.toggle('hidden', add); $('mce-del-btn').classList.toggle('hidden', add);
renderMcpHeaders(); renderMcpHeaders();
$('mcp-edit-modal').classList.remove('hidden'); $('mcp-edit-modal').classList.remove('hidden');
@@ -1530,7 +1536,7 @@
const edits = []; const edits = [];
const name = $('mce-name').value.trim(); const name = $('mce-name').value.trim();
const url = $('mce-url').value.trim(); const url = $('mce-url').value.trim();
const enable = $('mce-enable').checked; const mode = $('mce-mode').value;
// 超时:留空 = 不写入该项(沿用缺省 60s)。区间在 UI 先把一道, // 超时:留空 = 不写入该项(沿用缺省 60s)。区间在 UI 先把一道,
// 比写进 YAML 再被 config.js 静默夹掉好排查(两边上限保持 600000 一致)。 // 比写进 YAML 再被 config.js 静默夹掉好排查(两边上限保持 600000 一致)。
const tmoRaw = $('mce-timeout').value.trim(); const tmoRaw = $('mce-timeout').value.trim();
@@ -1545,7 +1551,7 @@
if (!url) throw new Error('请填写 url'); if (!url) throw new Error('请填写 url');
const obj = { url }; const obj = { url };
if (name) obj.name = name; if (name) obj.name = name;
if (!enable) obj.enable = false; if (mode !== 'advertise') obj.mode = mode;
if (tmo != null) obj.timeout_ms = tmo; if (tmo != null) obj.timeout_ms = tmo;
const headers = {}; const headers = {};
for (const r of mcpEdit.headers) { for (const r of mcpEdit.headers) {
@@ -1560,7 +1566,10 @@
if (!url) throw new Error('请填写 url'); if (!url) throw new Error('请填写 url');
if (name !== (cur.name || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'name'], value: name }); if (name !== (cur.name || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'name'], value: name });
if (url !== (cur.url || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'url'], value: url }); if (url !== (cur.url || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'url'], value: url });
if (!!cur.enable !== enable) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'enable'], value: enable }); // mode:默认值不写进文件(选 advertise 就删键)
if ((cur.mode || 'advertise') !== mode) edits.push(mode === 'advertise'
? { path: ['mcp_servers', mcpEdit.idx, 'mode'], op: 'delete' }
: { path: ['mcp_servers', mcpEdit.idx, 'mode'], value: mode });
// 超时:清空 = 删掉该键(回落到缺省);后端 deleteIn 支持嵌套键,无键时是空操作。 // 超时:清空 = 删掉该键(回落到缺省);后端 deleteIn 支持嵌套键,无键时是空操作。
const curTmo = cur.timeout_ms == null ? null : Number(cur.timeout_ms); const curTmo = cur.timeout_ms == null ? null : Number(cur.timeout_ms);
if (tmo !== curTmo) edits.push(tmo == null if (tmo !== curTmo) edits.push(tmo == null
+5 -4
View File
@@ -10,7 +10,7 @@ const multer = require('multer');
const YAML = require('yaml'); const YAML = require('yaml');
const engine = require('../engine'); const engine = require('../engine');
const llm = require('../llm'); const llm = require('../llm');
const { extractDescription, listSkills, formatSkillListForPrompt } = require('../tools/skills'); const { extractDescription, listCallableSkills, formatSkillListForPrompt } = require('../tools/skills');
const { sanitizeName } = require('./files'); const { sanitizeName } = require('./files');
const router = express.Router(); const router = express.Router();
@@ -77,9 +77,9 @@ function absInSkill(dir, rel) {
// 技能发生任何变更(创建/重命名/删除/文件增删改都经过本模块)后, // 技能发生任何变更(创建/重命名/删除/文件增删改都经过本模块)后,
// 重建 system prompt 的 “可用技能” 段落(llm.setSkillListText): // 重建 system prompt 的 “可用技能” 段落(llm.setSkillListText):
// 模型立即感知新技能或改名,无需重启。fire-and-forget:扫描失败不影响 API 响应, // 模型立即感知新技能或改名,无需重启。fire-and-forget:扫描失败不影响 API 响应,
// skill op=list 仍是实时兑底。 // skill {"list":"all"} 仍是实时兜底。
function refreshSkillPrompt() { function refreshSkillPrompt() {
listSkills({ cfg: engine.getConfig() }) listCallableSkills({ cfg: engine.getConfig() })
.then(list => llm.setSkillListText(formatSkillListForPrompt(list))) .then(list => llm.setSkillListText(formatSkillListForPrompt(list)))
.catch(() => {}); .catch(() => {});
} }
@@ -119,7 +119,8 @@ router.get('/', wrap(async (req, res) => {
let description = '(缺 SKILL.md)'; let description = '(缺 SKILL.md)';
let hasMd = false; let hasMd = false;
try { try {
description = extractDescription(await fsp.readFile(path.join(dir, 'SKILL.md'), 'utf8')); const content = await fsp.readFile(path.join(dir, 'SKILL.md'), 'utf8');
description = extractDescription(content);
hasMd = true; hasMd = true;
} catch (_) {} } catch (_) {}
const files = listSkillFiles(dir); const files = listSkillFiles(dir);
+1 -15
View File
@@ -11,8 +11,8 @@
// 顶层反向 require 会成环拿到半成品 exports。 // 顶层反向 require 会成环拿到半成品 exports。
const { CronExpressionParser } = require('cron-parser'); // 锁定 v5.10.1:API 是 CronExpressionParser.parse(v4 的 parseExpression 已不存在) const { CronExpressionParser } = require('cron-parser'); // 锁定 v5.10.1:API 是 CronExpressionParser.parse(v4 的 parseExpression 已不存在)
const log = require('./log'); const log = require('./log');
const { TZ, fmtTime, fmtIso } = require('./time'); // 业务时区单点;不依赖进程隐式时区
const TZ = 'Asia/Shanghai'; // 与容器 TZ(docker-compose)一致;显式传入,不依赖进程隐式时区
const TICK_MS = 30000; // 轮询周期:相对 1h 最小间隔足够密,无调优需求,不进 config.yml const TICK_MS = 30000; // 轮询周期:相对 1h 最小间隔足够密,无调优需求,不进 config.yml
const MIN_INTERVAL_MS = 3600000; // cron 最小间隔 1 小时:防 AI 排出分钟级任务反复烧模型池 const MIN_INTERVAL_MS = 3600000; // cron 最小间隔 1 小时:防 AI 排出分钟级任务反复烧模型池
const PROMPT_MAX_LEN = 20000; // prompt 长度上限,与 routes/sessions.js PATCH 口径一致 const PROMPT_MAX_LEN = 20000; // prompt 长度上限,与 routes/sessions.js PATCH 口径一致
@@ -21,20 +21,6 @@ let eng = null; // engine 引用(start 注入)
let notify = null; // 完成通知投递面(server.js 注入 wechat.notifyTask;缺位则跳过通知) let notify = null; // 完成通知投递面(server.js 注入 wechat.notifyTask;缺位则跳过通知)
let timer = null; let timer = null;
function fmtTime(t) {
return new Date(t).toLocaleString('zh-CN', { timeZone: TZ, hour12: false });
}
// ISO 带时区偏移串(schedule 工具回执用):上海无夏令时,固定 +08:00 安全;
// formatToParts 逐件拼接,不依赖 ICU 区域格式串形状;h23 保证零点为 00:00:00 而非 24 点。
function fmtIso(t) {
if (!t) return '';
const p = {};
const parts = new Intl.DateTimeFormat('en-CA', { timeZone: TZ, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23' }).formatToParts(new Date(t));
for (const { type, value } of parts) p[type] = value;
return p.year + '-' + p.month + '-' + p.day + 'T' + p.hour + ':' + p.minute + ':' + p.second + '+08:00';
}
// 下次到期时间。一律以当前时刻为基准(而非上次 next_run_at): // 下次到期时间。一律以当前时刻为基准(而非上次 next_run_at):
// 服务器停机跨过若干触发点后重启,算出的自然是「未来最近一次」,天然跳过补跑。 // 服务器停机跨过若干触发点后重启,算出的自然是「未来最近一次」,天然跳过补跑。
function computeNext(cronExpr) { function computeNext(cronExpr) {
+5 -4
View File
@@ -178,10 +178,10 @@ function dumpPromptBundle() {
// 启动时先发现各 MCP 服务的工具(单个服务失败只警告,不阻止启动), // 启动时先发现各 MCP 服务的工具(单个服务失败只警告,不阻止启动),
// 并对技能列表做快照(注入 system prompt,见 llm.setSkillListText),完成后开始监听。 // 并对技能列表做快照(注入 system prompt,见 llm.setSkillListText),完成后开始监听。
mcp.init(cfg).then(async () => { mcp.init(cfg).then(async () => {
// 技能列表快照:模型直接感知已有技能,免先 skill op=list 探索; // 技能列表快照:模型直接感知已有技能,免先 {"list":"all"} 探索;
// 此处失败不阻塞启动,skill op=list 仍可做实时兑底。 // 此处失败不阻塞启动,{"list":"all"} 仍可做实时兜底。
try { try {
const list = await skills.listSkills({ cfg }); const list = await skills.listCallableSkills({ cfg });
llm.setSkillListText(skills.formatSkillListForPrompt(list)); llm.setSkillListText(skills.formatSkillListForPrompt(list));
log.info('startup', ' skills=' + (list.length ? list.map(s => s.name).join(', ') : '(none)')); log.info('startup', ' skills=' + (list.length ? list.map(s => s.name).join(', ') : '(none)'));
} catch (e) { } catch (e) {
@@ -193,7 +193,8 @@ mcp.init(cfg).then(async () => {
log.info('startup', ' workspace_root=' + cfg.workspace_root); log.info('startup', ' workspace_root=' + cfg.workspace_root);
log.info('startup', ' data_root=' + cfg.data_root); log.info('startup', ' data_root=' + cfg.data_root);
log.info('startup', ' models=' + cfg.models.map(m => m.id + '@' + m.url).join(', ')); log.info('startup', ' models=' + cfg.models.map(m => m.id + '@' + m.url).join(', '));
const mcpList = (cfg.mcp_servers || []).map(s => s.name + '@' + s.url + (s.enable === false ? '(禁用)' : '')).join(', '); const mcpList = (cfg.mcp_servers || []).map(s => s.name + '@' + s.url +
(s.mode === 'disable' ? '(禁用)' : s.mode === 'skill' ? '(技能)' : '')).join(', ');
log.info('startup', ' mcp_servers=' + (mcpList || '(none)')); log.info('startup', ' mcp_servers=' + (mcpList || '(none)'));
log.info('startup', ' auth=' + (auth.enabled ? 'login: ' + cfg.auth.users.map(u => u.user).join(', ') : '(disabled)')); log.info('startup', ' auth=' + (auth.enabled ? 'login: ' + cfg.auth.users.map(u => u.user).join(', ') : '(disabled)'));
log.info('startup', ' wxbot=' + (cfg.wxbot.url && cfg.wxbot.token ? cfg.wxbot.url : '(未启用)')); log.info('startup', ' wxbot=' + (cfg.wxbot.url && cfg.wxbot.token ? cfg.wxbot.url : '(未启用)'));
+40
View File
@@ -0,0 +1,40 @@
// 业务时区单一入口:日记 day、定时任务 cron、存量迁移统一从这里取。
// Dockerfile/compose 的 TZ 只负责进程默认本地时区(日志、文件名、部分统计、第三方工具);
// 业务语义(day/cron)显式固定上海,不随部署环境或 TZ 覆盖漂移。
// 上海无夏令时:fmtIso 的 +08:00 是安全偏移;Intl 仍用 IANA 时区名。
const TZ = 'Asia/Shanghai';
const dayFmt = new Intl.DateTimeFormat('en-CA', { timeZone: TZ }); // en-CA = ISO 'YYYY-MM-DD'
const timeFmt = new Intl.DateTimeFormat('en-GB', {
timeZone: TZ, hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23'
});
const isoFmt = new Intl.DateTimeFormat('en-CA', {
timeZone: TZ, year: 'numeric', month: '2-digit', day: '2-digit',
hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23'
});
function dayString(ms) { return dayFmt.format(new Date(Number(ms) || Date.now())); }
// 'YYYY-MM-DD HH:MM:SS'(上海时区);脏/空值返 '',由调用方退回只显示 day。
function stampString(ms) {
const n = Number(ms);
if (!Number.isFinite(n) || n <= 0) return '';
const d = new Date(n);
return dayFmt.format(d) + ' ' + timeFmt.format(d);
}
function fmtTime(t) {
return new Date(t).toLocaleString('zh-CN', { timeZone: TZ, hour12: false });
}
// ISO 带时区偏移串(schedule 工具回执用):上海无夏令时,固定 +08:00 安全;
// formatToParts 逐件拼接,不依赖 ICU 区域格式串形状;h23 保证零点为 00:00:00 而非 24 点。
function fmtIso(t) {
if (!t) return '';
const p = {};
const parts = isoFmt.formatToParts(new Date(t));
for (const { type, value } of parts) p[type] = value;
return p.year + '-' + p.month + '-' + p.day + 'T' + p.hour + ':' + p.minute + ':' + p.second + '+08:00';
}
module.exports = { TZ, dayString, stampString, fmtTime, fmtIso };
+11 -15
View File
@@ -337,29 +337,25 @@
"type": "function", "type": "function",
"function": { "function": {
"name": "skill", "name": "skill",
"description": "Use the skills installed on this server. A skill is a directory under the skill root whose SKILL.md defines its purpose and input_schema.\n\nop=list No arguments.\nop=get Requires name.\nop=run Requires name; input_args optional (default {}).\n\nop=list: lists all installed skills with a one-line description each, read live from the skill root; use it to choose among skills or to confirm what is installed. An empty skill set returns an empty list — that is not an error.\nop=get: returns the full raw SKILL.md (front matter included): purpose, input_schema, and usage notes. Call it before op=run with a skill you have not used in this conversation. A nonexistent skill returns an error.\nop=run: executes the skill with input_args validated against its input_schema (a validation error names the missing fields). The entry script receives a JSON string as its only CLI argument, so input_args must be a JSON object.\n- Returns the skill's combined stdout+stderr as plain text after it exits; exit 0 with no output yields '(无输出)'. A non-zero exit raises an error containing the output and [exit code: N].\n- Direct output files via arguments: relative paths in input_args are resolved against the session working directory; do not rely on the skill's cwd.\n- Default timeout 120 seconds: the process group is killed and the error includes partial output collected so far (a timeout is not a skill failure).", "description": "Run or inspect the skills installed on this server. A skill is a directory under the skill root whose SKILL.md defines its purpose and input_schema.\n\nPass EXACTLY ONE verb key:\n{\"list\":\"all\"} List every installed skill with a one-line description, read live from the skill root; an empty list is not an error.\n{\"get\":\"<name>\"} Return the skill's full raw SKILL.md (front matter included): purpose, input_schema and usage notes. Call it before run for a skill you have not used in this conversation.\n{\"run\":\"<name>\",\"args\":{...}} Execute the skill; args are key/value pairs matching its input_schema, and may be omitted for skills that take none.\n\nrun returns the skill's combined stdout+stderr as plain text after it exits (exit 0 with no output yields '(无输出)'); a non-zero exit raises an error containing the output and [exit code: N]. Relative paths in args are resolved against the session working directory, so pass output paths explicitly and never rely on the skill's cwd. Default timeout 120 seconds: the process group is killed and the error includes partial output collected so far (a timeout is not a skill failure).",
"parameters": { "parameters": {
"type": "object", "type": "object",
"required": [
"op"
],
"properties": { "properties": {
"op": { "list": {
"type": "string", "type": "string",
"enum": [ "description": "Scope of the listing. The only scope today is \"all\" (every installed skill)."
"list",
"get",
"run"
],
"description": "Operation to perform on skills."
}, },
"name": { "get": {
"type": "string", "type": "string",
"description": "Name of the skill (subdirectory name under the skill root directory). Required with op=get and op=run." "description": "Skill name (subdirectory name under the skill root): return its SKILL.md."
}, },
"input_args": { "run": {
"type": "string",
"description": "Skill name: execute it with args."
},
"args": {
"type": "object", "type": "object",
"description": "Dictionary of input arguments for the skill. Keys and values should match the skill's input_schema (call op=get first if unsure). Example: {\"input\": \"file.md\", \"output\": \"out.pdf\"}. Used only with op=run; omit it for skills that take no arguments." "description": "Only with run: the skill's input arguments, e.g. {\"input\": \"file.md\", \"output\": \"out.pdf\"}. Omit it for skills that take no arguments."
} }
} }
} }
+85 -22
View File
@@ -12,9 +12,9 @@ const Database = require('better-sqlite3'); // db 工具:会话目录下的 da
const TurndownService = require('turndown'); // fetch 工具:HTML→Markdown 用真解析器(内置 htmlparser2,容错截断/畸形文档) const TurndownService = require('turndown'); // fetch 工具:HTML→Markdown 用真解析器(内置 htmlparser2,容错截断/畸形文档)
const rexec = require('../remote-exec'); const rexec = require('../remote-exec');
const publicFiles = require('../public-files'); const publicFiles = require('../public-files');
const scheduler = require('../scheduler'); // 只依赖 log/cron-parser,不成环(engine→executor→scheduler 单向) const scheduler = require('../scheduler'); // 只依赖 log/cron-parser/time.js,不成环(engine→executor→scheduler 单向)
const profile = require('../user-profile'); // profile 工具的数据面(仅 llm/log 依赖,无环) const profile = require('../user-profile'); // profile 工具的数据面(仅 llm/log 依赖,无环)
const memory = require('../memory'); // recall 工具的数据面(日记翻阅;零依赖模块,无环) const memory = require('../memory'); // recall 工具的数据面(日记翻阅;仅依赖 time.js,无环)
// lab 的 help 伪工具要读全量定义:与 engine 同路径 require → node 缓存同一对象,单一事实源。 // lab 的 help 伪工具要读全量定义:与 engine 同路径 require → node 缓存同一对象,单一事实源。
const BUILTIN_TOOL_DEFS = require('./definitions.json'); const BUILTIN_TOOL_DEFS = require('./definitions.json');
@@ -1498,11 +1498,18 @@ function toolDb(ctx, args) {
} }
} }
// skill:技能三件套(list_skills/get_skill_info/run_skill)合并后的单工具(op 分派)。 // skill:技能三件套(list/get/run)合并后的单工具(依据 docs/tool-design.md §一)。
// 同一标识空间(name)+ 同一生命周期(live 扫目录,无常驻状态可增删)→ 合并, // 参数形状是「动词作键、技能名作值」,三者恰好给一个:
// 依据 docs/tool-design.md §一;技能不是「无持久状态」的动作,run 不必单独成工具。 // {list:"all"} / {get:"<名>"} / {run:"<名>", args:{...}}
// input_args 仅 op=run 用且可缺省:runSkill 把 null 视作 {},真正缺哪些字段由 // list 的值是范围而非布尔:将来技能分类落地时直接扩成 {list:"<分类>"},调用形状不变,
// 各技能 input_schema 校验点名报错(工具层再 gate 一层是双重门槛,无益)。 // 模型不用学第二套写法。今天只认 "all" 且报错点名——静默返回全部会让错拼的分类名
// 看起来「能用」,将来接分类时更难排查。
// {list:"all"} 的清单 = 目录技能 + mode=skill 的 MCP 工具;get/run 对两者一视同仁:
// 目录技能读 SKILL.md,MCP 技能直接回注册表里的原始 input_schema。
// args 仅 run 用且可缺省:runSkill 把 null 视作 {},真正缺哪些字段由各技能 input_schema
// 校验点名报错(工具层再 gate 一层是双重门槛,无益)。
// 旧形状 {op, name, input_args} 仍接受:存量技能文档的调用示例里写的是它,模型 get 到
// 旧示例就会照着发;仅作兼容兜底,不再对外文档化(文档只体现新形状)。
// visit_url(front matter 可选):页面产物类技能声明访问路径模板,run 成功后在本层拼 // visit_url(front matter 可选):页面产物类技能声明访问路径模板,run 成功后在本层拼
// public_link.base_url(与 mint_public_link 同源)追加完整「访问地址」——技能进程跑在 // public_link.base_url(与 mint_public_link 同源)追加完整「访问地址」——技能进程跑在
// executor 隔离视图里不知道公网前缀,AI 拿到相对路径就会原样转给用户,而相对路径打不开。 // executor 隔离视图里不知道公网前缀,AI 拿到相对路径就会原样转给用户,而相对路径打不开。
@@ -1524,23 +1531,67 @@ async function runSkillWithVisit(ctx, name, inputArgs) {
: rel + '(站内路径:public_link.base_url 未配置,拼不出公网前缀)'); : rel + '(站内路径:public_link.base_url 未配置,拼不出公网前缀)');
} }
async function toolSkill(ctx, args) { const SKILL_USAGE = 'skill 用法:{"list":"all"} / {"get":"<技能名>"} / {"run":"<技能名>","args":{...}},三者恰好给一个';
const op = String(args.op || '').trim().toLowerCase();
const name = String(args.name || '').trim(); // 技能名必须是单 token:它要原样塞进 {run:"<名>"} 的值里,空格与等号会让日志与
// 报错里的表达产生歧义('/' 与 '..' 由 skills.skillDir 拦下)。
function skillNameArg(value, verb) {
if (typeof value !== 'string' || !value.trim()) {
throw new Error('skill ' + verb + ' 需要一个技能名字符串,收到:' + JSON.stringify(value).slice(0, 60) + '。' + SKILL_USAGE);
}
const name = value.trim();
if (/[\s=]/.test(name)) throw new Error('技能名不能含空格或等号:"' + name + '"');
return name;
}
// list/get 带非空 args 一律报错而不是静默丢弃:否则模型会以为参数生效了。
function rejectSkillArgs(a, verb) {
if (!a.args || typeof a.args !== 'object' || !Object.keys(a.args).length) return;
throw new Error(verb + ' 不接受 args,只有 run 才带参数。' + SKILL_USAGE);
}
// 旧形状 {op, name, input_args} 的等价翻译(兼容存量技能文档,见上方注释)。
async function legacyToolSkill(ctx, a) {
const op = String(a.op == null ? '' : a.op).trim().toLowerCase();
const name = String(a.name == null ? '' : a.name).trim();
switch (op) { switch (op) {
case 'list': case 'list':
return JSON.stringify(await skills.listSkills(ctx), null, 2); return JSON.stringify(await skills.listCallableSkills(ctx), null, 2);
case 'get': { case 'get':
if (!name) throw new Error('op=get 缺少必填参数 name'); if (!name) throw new Error('op=get 缺少技能名。' + SKILL_USAGE);
return skills.getSkillInfo(ctx, name);
case 'run':
if (!name) throw new Error('op=run 缺少技能名。' + SKILL_USAGE);
return runSkillWithVisit(ctx, name, a.input_args);
default:
throw new Error('未知的 op:"' + op + '"。' + SKILL_USAGE);
}
}
async function toolSkill(ctx, args) {
const a = args || {};
const verbs = ['list', 'get', 'run'].filter(k => a[k] !== undefined && a[k] !== null && a[k] !== false);
if (!verbs.length) {
// 三个动词键都没给时才回落到旧形状:两种都给时以新形状为准。
if (a.op !== undefined || a.name !== undefined || a.input_args !== undefined) return legacyToolSkill(ctx, a);
throw new Error(SKILL_USAGE);
}
if (verbs.length > 1) {
throw new Error('skill 一次只能给一个动词键,收到 ' + verbs.join(' + ') + '。' + SKILL_USAGE);
}
const verb = verbs[0];
if (verb === 'list') {
const scope = String(a.list).trim().toLowerCase();
if (scope !== 'all') throw new Error('list 目前只支持 "all"(技能分类尚未提供),收到:"' + scope + '"');
rejectSkillArgs(a, 'list');
return JSON.stringify(await skills.listCallableSkills(ctx), null, 2);
}
const name = skillNameArg(a[verb], verb);
if (verb === 'get') {
rejectSkillArgs(a, 'get');
return skills.getSkillInfo(ctx, name); return skills.getSkillInfo(ctx, name);
} }
case 'run': { return runSkillWithVisit(ctx, name, a.args);
if (!name) throw new Error('op=run 缺少必填参数 name');
return runSkillWithVisit(ctx, name, args.input_args);
}
default:
throw new Error('未知的 op:"' + op + '"。可用:list / get(需 name)/ run(需 name,input_args 可选)');
}
} }
// lab:全工具统一入口(元工具,tools 数组收缩到 1 个仍可达内置 + MCP 全部能力)。 // lab:全工具统一入口(元工具,tools 数组收缩到 1 个仍可达内置 + MCP 全部能力)。
@@ -1587,6 +1638,18 @@ function runLabHelp(args) {
// 历史成果文件不再归日记管:浏览/导入走 list_directory / copy_path 的 @<会话id>/<路径> 记号 // 历史成果文件不再归日记管:浏览/导入走 list_directory / copy_path 的 @<会话id>/<路径> 记号
// (校验单点 resolvePastPath),导入后就是本会话普通文件,read_file/mint 照常处理。 // (校验单点 resolvePastPath),导入后就是本会话普通文件,read_file/mint 照常处理。
// 旧 files/link 两 op 是 ls/mint 的沙箱外克隆,已整删(克隆必漂移:link 漏抄 mint 的 realpath 防线)。 // 旧 files/link 两 op 是 ls/mint 的沙箱外克隆,已整删(克隆必漂移:link 漏抄 mint 的 realpath 防线)。
// op=day 的 date 容错:模型可能把头部「date=YYYY-MM-DD HH:MM:SS」原样抄回。
// 只取开头的日期部分并补零/校验;不扫描全文找日期。
const RECALL_DAY_RE = /^(\d{4})[-/.年](\d{1,2})[-/.月](\d{1,2})(?!\d)/;
function normalizeRecallDay(v) {
const m = RECALL_DAY_RE.exec(String(v || '').trim());
if (!m) return '';
const y = Number(m[1]), mo = Number(m[2]), d = Number(m[3]);
const dt = new Date(Date.UTC(y, mo - 1, d));
if (dt.getUTCFullYear() !== y || dt.getUTCMonth() !== mo - 1 || dt.getUTCDate() !== d) return '';
return y + '-' + String(mo).padStart(2, '0') + '-' + String(d).padStart(2, '0');
}
function toolRecall(ctx, args) { function toolRecall(ctx, args) {
const op = String(args.op || '').trim().toLowerCase(); const op = String(args.op || '').trim().toLowerCase();
const db = ctx.db; const db = ctx.db;
@@ -1605,8 +1668,8 @@ function toolRecall(ctx, args) {
return '【日记索引】共 ' + list.length + ' 天(新在前):\n' + list.join('\n'); return '【日记索引】共 ' + list.length + ' 天(新在前):\n' + list.join('\n');
} }
case 'day': { case 'day': {
const date = String(args.date || '').trim(); const date = normalizeRecallDay(args.date);
if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) throw new Error('op=day 需要 date(YYYY-MM-DD,先用 op=days 查有哪些天)'); if (!date) throw new Error('op=day 需要 date(YYYY-MM-DD,先用 op=days 查有哪些天)');
const txt = memory.dayEntry(db, user, date); const txt = memory.dayEntry(db, user, date);
return txt ? date + ' 的日记:\n' + txt : date + ' 无日记。'; return txt ? date + ' 的日记:\n' + txt : date + ' 无日记。';
} }
+65 -19
View File
@@ -3,7 +3,10 @@
// 一次性处理——镜像已带的包跳过,缺的装进 skills/deps,运行期经 executor 容器 env 的 PYTHONPATH 可见。 // 一次性处理——镜像已带的包跳过,缺的装进 skills/deps,运行期经 executor 容器 env 的 PYTHONPATH 可见。
// 技能统一存放于技能根目录(cfg.skills_root,所有任务/会话共享;容器内挂 ./skills → /workspace/skills),每个技能一个子目录: // 技能统一存放于技能根目录(cfg.skills_root,所有任务/会话共享;容器内挂 ./skills → /workspace/skills),每个技能一个子目录:
// <skill>/SKILL.md(必须)、run.py | run.sh(入口)、requirements.txt、install.sh(可选)。 // <skill>/SKILL.md(必须)、run.py | run.sh(入口)、requirements.txt、install.sh(可选)。
// 入口脚本约定接收一个 JSON 字符串作为唯一命令行参数(含全部 input_args)。 // 入口脚本约定接收一个 JSON 字符串作为唯一命令行参数(含全部 args)。
// 后端两种:脚本(run.py/run.sh,落 executor 沙箱执行)与 MCP(core 直接 mcp.callTool 转发,
// 不经沙箱——凭证留在 core)。MCP 技能不落目录:服务配成 mode=skill 时由平台自动暴露,
// 参数契约直接取注册表里的原始 input_schema。
const fs = require('fs'); const fs = require('fs');
const fsp = require('fs').promises; const fsp = require('fs').promises;
const path = require('path'); const path = require('path');
@@ -11,6 +14,8 @@ const { spawn } = require('child_process');
const YAML = require('yaml'); const YAML = require('yaml');
const log = require('../log'); const log = require('../log');
const rexec = require('../remote-exec'); const rexec = require('../remote-exec');
// mode=skill 的 MCP 工具在 get/run 时由 core 直接转发;mcp.js 只依赖 ./log,不成环。
const mcp = require('../mcp');
class SkillNotFoundError extends Error { class SkillNotFoundError extends Error {
constructor(msg) { super(msg); this.name = 'SkillNotFoundError'; } constructor(msg) { super(msg); this.name = 'SkillNotFoundError'; }
@@ -48,7 +53,7 @@ function extractDescription(content) {
return line || '(无描述)'; return line || '(无描述)';
} }
// ---------- 3.1 skill op=list ---------- // ---------- 3.1 skill list ----------
async function listSkills(ctx) { async function listSkills(ctx) {
const root = skillsRoot(ctx); const root = skillsRoot(ctx);
if (!fs.existsSync(root)) { if (!fs.existsSync(root)) {
@@ -65,20 +70,49 @@ async function listSkills(ctx) {
try { content = await fsp.readFile(mdPath, 'utf8'); } catch (_) { continue; } try { content = await fsp.readFile(mdPath, 'utf8'); } catch (_) { continue; }
// frontmatter 可选 required: true —— 进 system prompt 时行首标 **required**(配合模板里的强制条款) // frontmatter 可选 required: true —— 进 system prompt 时行首标 **required**(配合模板里的强制条款)
let required = false; let required = false;
try { required = parseFrontMatter(content).required === true; } catch (_) {} try {
required = parseFrontMatter(content).required === true;
} catch (_) {}
out.push({ name: e.name, description: extractDescription(content), required: required }); out.push({ name: e.name, description: extractDescription(content), required: required });
} }
out.sort((a, b) => a.name.localeCompare(b.name)); out.sort((a, b) => a.name.localeCompare(b.name));
return out; return out;
} }
// ---------- system prompt 注入:可用技能列表 ---------- // ---------- MCP 技能(mode=skill)----------
// mode=skill 的服务:工具不进 tools 数组,而是自动成为技能。既省掉每轮的 schema 开销,
// 又不用在 skills_root 里建目录、手抄一份参数说明——get 直接返回注册表里的原始 input_schema。
// 目录技能优先:同名时目录技能胜出并打 warn。手写包装可以遮住自动版,迁移期也不会撞车。
// MCP 的 description 常是多段文本;清单里只取第一行,完整内容留给 get。
function firstLine(s) {
const line = String(s == null ? '' : s).split(/\r?\n/).map(l => l.trim()).find(Boolean);
return line || '(无描述)';
}
// 模型可见的技能全集 = 目录技能 + mode=skill 的 MCP 工具。
// 设置页的技能 API 只用 listSkills(它按目录增删改),不要混用这个函数。
async function listCallableSkills(ctx) {
const dir = await listSkills(ctx);
const taken = new Set(dir.map(s => s.name));
const out = dir.slice();
for (const t of mcp.skillTools()) {
if (taken.has(t.name)) {
log.warn('skills', 'MCP 工具 ' + t.name + ' 与目录技能同名,按目录技能处理(mode=skill 的这份被遮蔽)');
continue;
}
out.push({ name: t.name, description: firstLine(t.description), required: false });
}
out.sort((a, b) => a.name.localeCompare(b.name));
return out;
}
// 把技能列表格式化成 “## Available Skills” 段落(每行 `- [**required** ]名字: 描述`; // 把技能列表格式化成 “## Available Skills” 段落(每行 `- [**required** ]名字: 描述`;
// listSkills 已按名字 localeCompare 排序,行序恒定,不破坏前缀缓存; // listSkills 已按名字 localeCompare 排序,行序恒定,不破坏前缀缓存;
// 参数查 op=get,执行 op=run;描述如需实时复核仍可查 op=list)。 // 参数查 get,执行 run;描述如需实时复核仍可查 list)。
// 由 llm.setSkillListText 拼入 system prompt:启动时快照(server.js)与技能变更后 // 由 llm.setSkillListText 拼入 system prompt:启动时快照(server.js)与技能变更后
// (routes/skills.js 的创建/重命名/删除/文件变更)调用,让模型直接感知已装技能, // (routes/skills.js 的创建/重命名/删除/文件变更)调用,让模型直接感知已装技能,
// 省掉先 op=list 探索的往返。 // 省掉先 list 探索的往返。
function formatSkillListForPrompt(list) { function formatSkillListForPrompt(list) {
if (!list || !list.length) return ''; if (!list || !list.length) return '';
const lines = list.map(s => { const lines = list.map(s => {
@@ -89,14 +123,16 @@ function formatSkillListForPrompt(list) {
return '## Available Skills\n' + lines.join('\n'); return '## Available Skills\n' + lines.join('\n');
} }
// ---------- 3.2 skill op=get ---------- // ---------- 3.2 skill get ----------
async function getSkillInfo(ctx, skillName) { async function getSkillInfo(ctx, skillName) {
const dir = skillDir(ctx, skillName); const dir = skillDir(ctx, skillName);
const mdPath = path.join(dir, 'SKILL.md'); const mdPath = path.join(dir, 'SKILL.md');
if (!fs.existsSync(mdPath)) { if (fs.existsSync(mdPath)) return fsp.readFile(mdPath, 'utf8');
// mode=skill 的 MCP 技能没有目录:直接返回注册表里的原始契约(description + input_schema),
// 模型看到的就是服务端实际声明的参数,不存在手抄副本漂移的问题。
const t = mcp.getSkillTool(skillName);
if (t) return JSON.stringify({ name: t.name, description: t.description, input_schema: t.parameters }, null, 2);
throw new SkillNotFoundError('技能不存在或缺少 SKILL.md:' + skillName); throw new SkillNotFoundError('技能不存在或缺少 SKILL.md:' + skillName);
}
return fsp.readFile(mdPath, 'utf8');
} }
// ---------- 参数路径预处理 ---------- // ---------- 参数路径预处理 ----------
@@ -123,7 +159,7 @@ function absolutizeArgs(inputArgs, baseDir) {
return out; return out;
} }
// 按 input_schema 校验 input_args(仅校验 required 字段存在且非空)。 // 按 input_schema 校验技能参数(仅校验 required 字段存在且非空)。
function validateArgs(fm, inputArgs, skillName) { function validateArgs(fm, inputArgs, skillName) {
const schema = fm && fm.input_schema; const schema = fm && fm.input_schema;
if (!schema || !Array.isArray(schema.required)) return; if (!schema || !Array.isArray(schema.required)) return;
@@ -135,7 +171,7 @@ function validateArgs(fm, inputArgs, skillName) {
// 前台执行技能入口,带超时与取消支持;成功 resolve stdout,失败 reject SkillExecutionError。 // 前台执行技能入口,带超时与取消支持;成功 resolve stdout,失败 reject SkillExecutionError。
// 配了 executor:入口命令拼成单条 shell 行(参数单引号转义,JSON payload 安全)交远端执行, // 配了 executor:入口命令拼成单条 shell 行(参数单引号转义,JSON payload 安全)交远端执行,
// cwd 由调用方给出(op=run 传会话目录以命中 session 隔离与虚拟视图); // cwd 由调用方给出(run 传会话目录以命中 session 隔离与虚拟视图);
// 技能依赖的 PYTHONPATH 由 executor 容器 env 提供,core 不感知依赖层。 // 技能依赖的 PYTHONPATH 由 executor 容器 env 提供,core 不感知依赖层。
function runEntry(ctx, entry, args, cwd, timeoutMs) { function runEntry(ctx, entry, args, cwd, timeoutMs) {
const cfg = ctx.cfg; const cfg = ctx.cfg;
@@ -199,24 +235,34 @@ function runEntry(ctx, entry, args, cwd, timeoutMs) {
}); });
} }
// ---------- 3.3 skill op=run ---------- // ---------- 3.3 skill run ----------
async function runSkill(ctx, skillName, inputArgs) { async function runSkill(ctx, skillName, inputArgs) {
// 非对象参数会在 absolutizeArgs 的 Object.entries 里静默错位成垃圾键值(如字符串→索引对象),显式拦下。 // 非对象参数会在 absolutizeArgs 的 Object.entries 里静默错位成垃圾键值(如字符串→索引对象),显式拦下。
if (inputArgs != null && (typeof inputArgs !== 'object' || Array.isArray(inputArgs))) { if (inputArgs != null && (typeof inputArgs !== 'object' || Array.isArray(inputArgs))) {
throw new SkillExecutionError('input_args 必须是对象(键值参数),收到:' + JSON.stringify(inputArgs).slice(0, 80), 1); throw new SkillExecutionError('技能参数必须是对象(键值参数),收到:' + JSON.stringify(inputArgs).slice(0, 80), 1);
} }
const dir = skillDir(ctx, skillName); const dir = skillDir(ctx, skillName);
if (!fs.existsSync(dir)) throw new SkillNotFoundError('技能不存在:' + skillName); if (!fs.existsSync(dir)) {
// mode=skill 的 MCP 技能:直接转发。同样不做 absolutizeArgs——URL 与含 '/' 的 prompt
// 会被当成路径改写坏;也不做 validateArgs,参数与 MCP 工具自己的 op 相关。
const t = mcp.getSkillTool(skillName);
if (t) {
log.info('skills', '执行 MCP 技能 ' + t.name + ' → ' + t.server + '/' + t.tool);
return mcp.callTool(t.name, inputArgs || {}, ctx);
}
throw new SkillNotFoundError('技能不存在:' + skillName);
}
const mdPath = path.join(dir, 'SKILL.md'); const mdPath = path.join(dir, 'SKILL.md');
if (!fs.existsSync(mdPath)) throw new SkillNotFoundError('技能缺少 SKILL.md:' + skillName); if (!fs.existsSync(mdPath)) throw new SkillNotFoundError('技能缺少 SKILL.md:' + skillName);
// 先把相对路径参数按会话任务目录转成绝对路径(缺任务目录时退回进程当前目录)。 let fm = {};
try { fm = parseFrontMatter(await fsp.readFile(mdPath, 'utf8')); } catch (_) {}
// 以下是脚本后端(run.py / run.sh):先把相对路径参数按会话任务目录转成绝对路径(缺任务目录时退回进程当前目录)。
const args = absolutizeArgs(inputArgs || {}, ctx.taskDir || process.cwd()); const args = absolutizeArgs(inputArgs || {}, ctx.taskDir || process.cwd());
const payload = JSON.stringify(args); const payload = JSON.stringify(args);
let fm = {};
try { fm = parseFrontMatter(await fsp.readFile(mdPath, 'utf8')); } catch (_) {}
validateArgs(fm, args, skillName); validateArgs(fm, args, skillName);
let entry, cmdArgs; let entry, cmdArgs;
@@ -243,4 +289,4 @@ async function runSkill(ctx, skillName, inputArgs) {
return runEntry(ctx, entry, cmdArgs, execCwd, timeoutMs); return runEntry(ctx, entry, cmdArgs, execCwd, timeoutMs);
} }
module.exports = { listSkills, getSkillInfo, runSkill, skillsRoot, parseFrontMatter, extractDescription, formatSkillListForPrompt }; module.exports = { listSkills, listCallableSkills, getSkillInfo, runSkill, skillsRoot, parseFrontMatter, extractDescription, formatSkillListForPrompt };
+3
View File
@@ -25,6 +25,9 @@
- 跨 op 共享的参数放顶层,description 说明哪些 op 用它; - 跨 op 共享的参数放顶层,description 说明哪些 op 用它;
- op 专属参数也放顶层,description 说明 `op=X 时必填`; - op 专属参数也放顶层,description 说明 `op=X 时必填`;
- 仅当参数结构在工具定义时无法确定时,才用自由对象 `{ "type": "object" }`。 - 仅当参数结构在工具定义时无法确定时,才用自由对象 `{ "type": "object" }`。
- 动词 + 单 token 标识可以折叠成「动词作键、标识作值」(技能的 `{"get":"<名>"}` 即此形)。
多个动词互斥时 `required` 表达不了,必须在代码里校验,并在报错里回显全部合法形态;
取值范围暂只有一个时(如 `{"list":"all"}`)仍用字符串而非布尔,便于后续扩成分类等子集。
### 四、条件必填 ### 四、条件必填
+1 -1
View File
@@ -303,7 +303,7 @@ function buildServer() {
server.tool( server.tool(
"image_task", "image_task",
`Manages asynchronous image generation tasks. `AI image generation.
op=create Submit a new task. Returns a task_id immediately; generation runs in background. op=create Submit a new task. Returns a task_id immediately; generation runs in background.
Requires prompt. Requires prompt.
+1 -1
View File
@@ -336,7 +336,7 @@ function buildServer() {
server.tool( server.tool(
"video_task", "video_task",
`Manages asynchronous video generation tasks. `AI video generation.
op=create Submit a new task. Returns a task_id immediately; generation runs asynchronously. op=create Submit a new task. Returns a task_id immediately; generation runs asynchronously.
Requires at least one of prompt or image_url. Requires at least one of prompt or image_url.
+7 -5
View File
@@ -11,7 +11,7 @@
# 输入(都可选): # 输入(都可选):
# BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY 模型平台 key,填几个启用几个(0~3 个) # BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY 模型平台 key,填几个启用几个(0~3 个)
# image_task / video_task 复用 BIGMODEL_KEY(智谱即 BigModel); # image_task / video_task 复用 BIGMODEL_KEY(智谱即 BigModel);
# 未配 BIGMODEL_KEY 时这两个服务写为 enable: false # 未配 BIGMODEL_KEY 时这两个服务写为 mode: disable
# AUTH_USER / AUTH_PASSWORD 登录账号(默认 admin / admin,请自行改掉) # AUTH_USER / AUTH_PASSWORD 登录账号(默认 admin / admin,请自行改掉)
# PUBLIC_IP / AGENT_PORT 对外地址与端口,写进 public_link.base_url; # PUBLIC_IP / AGENT_PORT 对外地址与端口,写进 public_link.base_url;
# PUBLIC_IP 不配置则自动探测公网 IP # PUBLIC_IP 不配置则自动探测公网 IP
@@ -211,19 +211,21 @@ EOF
url: "http://mcp_image_task:3000/mcp" url: "http://mcp_image_task:3000/mcp"
headers: headers:
Authorization: "Bearer $BIGMODEL_KEY" Authorization: "Bearer $BIGMODEL_KEY"
mode: skill # 不下发给模型,以技能形式暴露(skill 工具里 list/get/run)
- name: video_task - name: video_task
url: "http://mcp_video_task:3000/mcp" url: "http://mcp_video_task:3000/mcp"
headers: headers:
Authorization: "Bearer $BIGMODEL_KEY" Authorization: "Bearer $BIGMODEL_KEY"
mode: skill
EOF EOF
else else
cat <<'EOF' cat <<'EOF'
- name: image_task - name: image_task
url: "http://mcp_image_task:3000/mcp" url: "http://mcp_image_task:3000/mcp"
enable: false # 未配 BIGMODEL_KEY:只注册不加载,工具不发给模型 mode: disable # 未配 BIGMODEL_KEY:不连接、不发现;补上 key 后重跑本脚本
- name: video_task - name: video_task
url: "http://mcp_video_task:3000/mcp" url: "http://mcp_video_task:3000/mcp"
enable: false # 未配 BIGMODEL_KEY:只注册不加载,工具不发给模型 mode: disable # 未配 BIGMODEL_KEY:不连接、不发现;补上 key 后重跑本脚本
EOF EOF
fi fi
@@ -235,7 +237,7 @@ public_link:
EOF EOF
} > "$CONFIG_YML" } > "$CONFIG_YML"
info "平台: ${enabled_plats[*]:-无};图像/视频 MCP: $([ -n "$BIGMODEL_KEY" ] && echo 启用 || echo 未配置(enable: false))" info "平台: ${enabled_plats[*]:-无};图像/视频 MCP: $([ -n "$BIGMODEL_KEY" ] && echo 启用 || echo 未配置(mode: disable))"
# ============================================================ # ============================================================
# 3. 汇总 # 3. 汇总
@@ -246,7 +248,7 @@ echo " 访问地址 : http://${PUBLIC_IP:-<公网IP>}:${AGENT_PORT}"
echo " 账号 : $AUTH_USER" echo " 账号 : $AUTH_USER"
echo " 密码 : $AUTH_PASSWORD" echo " 密码 : $AUTH_PASSWORD"
echo " 平台 : ${enabled_plats[*]:-(无)}" echo " 平台 : ${enabled_plats[*]:-(无)}"
echo " 图像/视频: $([ -n "$BIGMODEL_KEY" ] && echo "image_task / video_task 已启用" || echo "未配置(enable: false)")" echo " 图像/视频: $([ -n "$BIGMODEL_KEY" ] && echo "image_task / video_task 已启用" || echo "未配置(mode: disable)")"
echo " MCP 服务 : web_search / image_task / video_task(同栈,随 compose 启动)" echo " MCP 服务 : web_search / image_task / video_task(同栈,随 compose 启动)"
echo " 微信接入 : WXBOT_TOKEN 已就位(compose 注入 core 与 wxbot 两侧;wxbot 无需配置文件)" echo " 微信接入 : WXBOT_TOKEN 已就位(compose 注入 core 与 wxbot 两侧;wxbot 无需配置文件)"
echo "---------------------------------------------" echo "---------------------------------------------"
+31 -8
View File
@@ -8,9 +8,9 @@
技能是一个自包含的目录,通常存放在技能根目录(默认为 `skills/`)下。每个技能包含一个描述文件(`SKILL.md`)和一个可执行入口(`run.py` 或 `run.sh`)。Agent 通过以下流程使用技能: 技能是一个自包含的目录,通常存放在技能根目录(默认为 `skills/`)下。每个技能包含一个描述文件(`SKILL.md`)和一个可执行入口(`run.py` 或 `run.sh`)。Agent 通过以下流程使用技能:
1. 调用 `skill`(op=list)查看所有可用技能的名称和简介; 1. 调用 `skill` 的 `{"list":"all"}` 查看所有可用技能的名称和简介;
2. 调用 `skill`(op=get)获取某个技能的详细说明; 2. 调用 `skill` 的 `{"get":"<技能名>"}` 获取某个技能的详细说明;
3. 调用 `skill`(op=run)执行技能,传入所需参数。 3. 调用 `skill` 的 `{"run":"<技能名>","args":{...}}` 执行技能,传入所需参数。
技能可以处理任何任务,例如文件格式转换、数据处理、网页抓取等。 技能可以处理任何任务,例如文件格式转换、数据处理、网页抓取等。
@@ -57,10 +57,10 @@ visit_url: /app/{task_id}/ # 可选:页面类技能的访问路径模板
``` ```
- `name`:技能名称,应与目录名一致。 - `name`:技能名称,应与目录名一致。
- `description`:一句话描述技能功能,用于 `skill` op=list 展示。 - `description`:一句话描述技能功能,用于 `{"list":"all"}` 的清单展示。
- `input_schema`:输入参数的 JSON Schema 定义,用于参数校验和文档生成。 - `input_schema`:输入参数的 JSON Schema 定义,用于参数校验和文档生成。
- `output_schema`:输出结果的描述(可选)。 - `output_schema`:输出结果的描述(可选)。
- `visit_url`:(可选)页面类技能声明的访问路径模板,`{task_id}` 占位执行时替换为会话 id。`op=run` 成功后由 core(tools/executor.js)拼上 `public_link.base_url`,在输出末尾追加一行「访问地址:<完整 URL>」——技能进程跑在 executor 隔离视图里不知道公网地址,完整链接只能 core 补;AI 拿到相对路径会原样转给用户,而相对路径打不开。 - `visit_url`:(可选)页面类技能声明的访问路径模板,`{task_id}` 占位执行时替换为会话 id。`run` 成功后由 core(tools/executor.js)拼上 `public_link.base_url`,在输出末尾追加一行「访问地址:<完整 URL>」——技能进程跑在 executor 隔离视图里不知道公网地址,完整链接只能 core 补;AI 拿到相对路径会原样转给用户,而相对路径打不开。
- 若未提供 Front Matter,系统会尝试从正文第一行提取描述。 - 若未提供 Front Matter,系统会尝试从正文第一行提取描述。
### 3.2 正文内容 ### 3.2 正文内容
@@ -80,13 +80,36 @@ visit_url: /app/{task_id}/ # 可选:页面类技能的访问路径模板
- 自动处理某某 - 自动处理某某
## 使用说明 ## 使用说明
通过 `skill`(op=run)调用,参数: 通过 `skill` 的 `{"run":"<技能名>","args":{...}}` 调用,参数:
- `input`:某某路径(必填) - `input`:某某路径(必填)
- `output`:某某路径(可选,默认与输入同名) - `output`:某某路径(可选,默认与输入同名)
``` ```
--- ---
### 3.3 MCP 后端技能(不建目录)
把 `config.yml` 里某个 MCP 服务配成 `mode: skill` 即可:它的每个工具会自动成为技能,不需要
`SKILL.md`,也不需要入口脚本。
- `{"list":"all"}` 里出现工具名,描述取 MCP `description` 的第一行;
- `{"get":"<工具名>"}` 直接返回 MCP 原始的 `description` + `input_schema`(单一来源,不会与
实现漂移);
- `{"run":"<工具名>","args":{…}}` 把 `args` 原样透传成 MCP 的 `arguments`,由 core 直接转发。
几个约束:
- 参数校验交给 MCP 服务,core 不做 `input_schema.required` 预检(MCP 工具的参数常与它自己的
`op` 相关,静态必填列表会误伤)。
- `args` **不做相对路径改写**:服务拿到什么就是什么。URL、含 `/` 的 prompt 因此不会被改坏,
但本地文件路径也不会被自动补全——需要公网 URL 的先用 `mint_public_link`。
- 不经过沙箱,所以不需要密钥:凭证留在 core 的 `mcp_servers[].headers` 里。
- 工具名用**最终可调用名**(与内置工具重名时会被加 `<服务名>__` 前缀,见 `app/AGENTS.md`)。
- 与目录技能同名时目录技能优先,自动暴露的那份被遮蔽并打 `warn`。
- 启动日志会打印 `mode=skill` 的工具数量,便于确认暴露是否生效。
---
## 4. 入口脚本 ## 4. 入口脚本
### 4.1 格式要求 ### 4.1 格式要求
@@ -176,7 +199,7 @@ Agent 调用技能时,传入的文件路径可能是相对路径(相对于
- **运行时的工作目录是「会话任务目录」,不是技能目录**(远端模式下即 executor 隔离视图里的 `/workspace/tasks/<会话>`)。技能进程只能看到当前会话的数据,看不到其他会话。 - **运行时的工作目录是「会话任务目录」,不是技能目录**(远端模式下即 executor 隔离视图里的 `/workspace/tasks/<会话>`)。技能进程只能看到当前会话的数据,看不到其他会话。
- 因此技能内部引用**自身资源**(模板、字体、配置等)时,**必须**基于脚本位置取绝对路径,不要依赖 cwd:Python 用 `Path(__file__).resolve().parent`,Shell 用 `"$(dirname "$0")"`。 - 因此技能内部引用**自身资源**(模板、字体、配置等)时,**必须**基于脚本位置取绝对路径,不要依赖 cwd:Python 用 `Path(__file__).resolve().parent`,Shell 用 `"$(dirname "$0")"`。
- 读写会话数据用 `input_args` 里传入的路径即可;相对路径会被预转绝对路径,且在隔离视图里与 Agent 看到的是同一份数据。 - 读写会话数据用 `args` 里传入的路径即可;相对路径会被预转绝对路径,且在隔离视图里与 Agent 看到的是同一份数据。
--- ---
@@ -228,7 +251,7 @@ input_schema:
--- ---
## 使用说明 ## 使用说明
通过 `skill`(op=run)调用,参数: 通过 `skill` 的 `{"run":"<技能名>","args":{...}}` 调用,参数:
- `text`:要回显的文本(必填) - `text`:要回显的文本(必填)
``` ```
+2 -2
View File
@@ -31,7 +31,7 @@ visit_url: /app/{task_id}/
## 初始化 ## 初始化
调用 `skill(name="data-page", op="run")`,无需参数。它会把以下文件复制到 `.app/`: 调用 `skill {"run":"data-page"}`,无需参数。它会把以下文件复制到 `.app/`:
- `table.html` / `dashboard.html` / `kanban.html` —— 三个数据页模板 - `table.html` / `dashboard.html` / `kanban.html` —— 三个数据页模板
- `nav.html` —— 多页导航首页模板(静态卡片,无 config) - `nav.html` —— 多页导航首页模板(静态卡片,无 config)
@@ -80,7 +80,7 @@ const taskId = location.pathname.split('/').filter(Boolean)[1];
1. **明确数据结构**:与用户确认字段。如果描述模糊,可以建议合理的结构。 1. **明确数据结构**:与用户确认字段。如果描述模糊,可以建议合理的结构。
2. **创建表并录入数据**:用 `db` 工具完成。 2. **创建表并录入数据**:用 `db` 工具完成。
3. **初始化**:调用 `skill(name="data-page", op="run")`。 3. **初始化**:调用 `skill {"run":"data-page"}`。
4. **为每个要生成的页面写 config 文件**(见下一节)。**不要读也不要改模板本身**。 4. **为每个要生成的页面写 config 文件**(见下一节)。**不要读也不要改模板本身**。
5. **选定入口页 `.app/index.html`**(index 是副本,允许编辑;模板本体不动): 5. **选定入口页 `.app/index.html`**(index 是副本,允许编辑;模板本体不动):
- **用到 ≥2 个模板页** → `cp .app/nav.html .app/index.html`,改标题为业务名,并把未启用页面的卡片删掉(没配过的页点开会报 no such table)。子页标题左侧的「‹」返回键链回此导航页。 - **用到 ≥2 个模板页** → `cp .app/nav.html .app/index.html`,改标题为业务名,并把未启用页面的卡片删掉(没配过的页点开会报 no such table)。子页标题左侧的「‹」返回键链回此导航页。
+1 -1
View File
@@ -25,7 +25,7 @@ def main():
try: try:
args = json.loads(sys.argv[1]) args = json.loads(sys.argv[1])
if not isinstance(args, dict): if not isinstance(args, dict):
raise ValueError('input_args 必须是 JSON 对象') raise ValueError('技能参数必须是 JSON 对象')
if args: if args:
print('本技能无参数,收到:' + json.dumps(args, ensure_ascii=False), print('本技能无参数,收到:' + json.dumps(args, ensure_ascii=False),
file=sys.stderr) file=sys.stderr)
+1 -1
View File
@@ -87,7 +87,7 @@ output_schema:
- `grid`:把同一目录下多张图拼成一张 contact sheet(缩略图网格) - `grid`:把同一目录下多张图拼成一张 contact sheet(缩略图网格)
## 使用说明 ## 使用说明
通过 `skill`(op=run)调用,参数 `input_args`: 通过 `skill` 的 `{"run":"img-utils","args":{...}}` 调用,参数:
- `action`:操作类型(必填) - `action`:操作类型(必填)
- `input`:输入图片或目录(必填;相对会话工作目录的路径即可,会自动转绝对路径) - `input`:输入图片或目录(必填;相对会话工作目录的路径即可,会自动转绝对路径)
- `output`:输出路径(建议给全;不给时自动生成 `<原名>_<动作>.<原扩展名>`,绝不覆盖原图) - `output`:输出路径(建议给全;不给时自动生成 `<原名>_<动作>.<原扩展名>`,绝不覆盖原图)
+1 -1
View File
@@ -66,7 +66,7 @@ output_schema:
## 调用方式 ## 调用方式
通过 `skill`(op=run)调用,参数: 通过 `skill` 的 `{"run":"x2pdf","args":{...}}` 调用,参数:
- `input`:输入文件路径(必填) - `input`:输入文件路径(必填)
- `output`:PDF 输出路径(可选,默认与输入同名) - `output`:PDF 输出路径(可选,默认与输入同名)
- `css`:自定义 CSS 文件路径(可选,仅 md/html/txt) - `css`:自定义 CSS 文件路径(可选,仅 md/html/txt)