agent-loft 0.2.31 → 0.2.32

package/README.md

@@ -59,6 +59,7 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
 - **聊天模式 / 工作模式**：右上角的「💬 聊天 / 🛠 工作」，或者发 `/chat`、`/work`，同一条对话随时切换、上下文接着。聊天模式换成精简的系统提示，只留联网搜索，不加载技能、MCP、插件，不执行命令、不读写本机文件（文本附件的内容直接放进消息），每轮的固定开销小得多：实测一句话 Claude 约 1.6 万 → 2 千 token，Codex 约 2 万 → 1.2 万（Codex 的基础指令改不了）。适合日常聊天、查资料；要动手干活时切回工作模式。切换后第一轮要重建提示缓存，会贵一些；在工作模式里读过的大段内容还留在历史里。
 - **记忆**：像 ChatGPT 的记忆，设置 → 记忆。「关于我」加上一条条记住的事，每次对话都带上；agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条（回复里会说），记错了用 `forget` 删。**自动整理**：把上次整理之后新说的话交给模型（不留会话记录的一次性调用），补充、更新或删掉过时的记忆，用户自己加的条目它不动。什么时候整理每个人自己定：每天一次（默认凌晨 4 点，把当天的对话合起来一次整理，最省）／每段对话聊完后（停多久可选，改了什么会在对话里说一声）／只在点「现在整理」时／不整理；整理哪些对话也能选：全部／只整理聊天模式的／只整理工作模式的；用哪个 agent 的哪个模型也能选，默认 Claude Haiku，没有 Claude 就用 Codex 的默认模型、思考程度 low。**参考以前的聊天**：agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话（关键词搜索，只有你自己的、没被删掉的对话；第一次用时会把已有对话收录进来）。两项都能在设置里单独关。每个用户一份，Claude 和 Codex、Web 和飞书共用。只用在有主人的对话里：你的 Web 对话，以及绑定了飞书账号后和机器人的私聊；飞书群聊不用。别人（包括管理员）看不到你的记忆，管理员只能清空它；删用户时记忆一起删，不转给管理员。
 - **定时任务**：像 ChatGPT 的 Tasks，侧栏「最近」上面的「定时任务」。到点把一段提示词交给 agent，结果发回对话：一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron，按服务端时区，两次至少隔 15 分钟。**有需要才提醒**（默认）：agent 自己判断这次有没有要告诉你的事（比如「有新版本才告诉我」），没有就在回复第一行写 `[[静默]]`，推送、飞书都不发，对话里折叠成一行；没写暗号一律照常提醒。结果发到**专用对话**（任务自己的一条对话，第一次运行时新建、之后续用，可选聊天 / 工作模式和目录），或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」：agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理，新建、修改、删除都会先弹授权卡让你确认（只有暂停不用；没有「总是允许」），任务自己运行的那一轮里不能再建、改、删任务。按人隔离：每人只看得到、改得了自己的任务（最多 30 个），删用户时一起删；到点再核对一次对话还是不是他的，对话被删或换了主人就暂停任务。到点对话在忙（正在回复或挂着授权）就等它，最多 30 分钟；服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话，飞书群聊里没有。
+- **技能（skills）**：侧栏「定时任务」下面的「技能」。技能就是 Claude Code / Codex 用的那种 SKILL.md（可以带脚本和资料），由 agent-loft 按人管理，两个 agent 都能用。**来源**：在页面上写、上传技能包（`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹），或者在对话里让 agent「把刚才的做法存成技能」（agent 用 `create_skill` / `update_skill`，先弹授权卡）。**分享**：作者选谁看得到——仅自己 / 指定的人 / 所有人；看得到的人在「技能广场」里安装。装的是作者那一份本身，作者改了，装了的人下一条消息起就用上新的；作者取消分享或删掉，装了的人也就没了。管理员能下架别人分享出来的技能，看不到别人私有的。**使用**：工作模式下 agent 遇到对得上的事自己用；在输入框或定时任务的「要做的事」里打 `@` 选技能，点名这次用哪个（聊天模式下会把技能内容直接附上）；飞书里发 `/skills` 看能 @ 哪些。**变量**：技能可以声明要用的环境变量（接口地址、密钥），每个人填自己的值，只注入自己的会话；密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量，agent 看不到值，只能用 `skill_request` 工具让 agent-loft 代发请求（在地址、请求头、请求体里写 `{{变量名}}`），只发往你确认过的地址、不跟随跳转、响应里出现的值会被抹掉；作者后来改了地址，要你再确认一次才放行。**机器上原有的技能**（`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的）只给管理员：成员的会话里看不到、调不了（Claude 用技能白名单，`/技能名` 也会被拦下；Codex 关掉它自己的技能清单），管理员在技能页的「本机技能」里能看到。
 - **飞书账号绑定**：设置 → 账号 → 飞书账号 →「生成绑定码」，再在飞书私聊机器人发 `/bind 绑定码`（10 分钟内有效，群里发不算）。绑定后这个私聊就是你的个人会话：用你的记忆，`/sessions` 只列你的会话，`/web` 只能接上你自己的 Web 会话，管理员在 Web 上也看不到它。必须本人在两边各操作一次，管理员不能替人绑定（只能解除），否则就能借飞书读到别人的记忆。
 
 ## 安装
@@ -129,7 +130,7 @@ agent-loft service install
 
 `aloft` 是 `agent-loft` 的简写。
 
-聊天里的命令（飞书和 Web 通用；Web 输入框打 `/` 会弹出命令补全，飞书里打 `/` 会弹出机器人的指令面板（agent-loft 自动注册，约 5～8 分钟生效；只发一个 `/` 也会回一张可点击的命令卡片），顺序和显示项在 设置 → 命令 里调整）：`/new` `/fork` `/sessions [all]` `/resume <id>` `/model [名称]` `/effort <程度>` `/agent [名称]`（或者直接发 `/claude`、`/codex`）`/stop` `/cd <目录>` `/pwd` `/status` `/autoedit [on|off]` `/approve <id> allow-once|allow-always|allow-session|deny` `/chat` `/work` `/help`；只在飞书里有的：`/web` `/detach` `/bind <绑定码>`
+聊天里的命令（飞书和 Web 通用；Web 输入框打 `/` 会弹出命令补全，飞书里打 `/` 会弹出机器人的指令面板（agent-loft 自动注册，约 5～8 分钟生效；只发一个 `/` 也会回一张可点击的命令卡片），顺序和显示项在 设置 → 命令 里调整）：`/new` `/fork` `/sessions [all]` `/resume <id>` `/model [名称]` `/effort <程度>` `/agent [名称]`（或者直接发 `/claude`、`/codex`）`/stop` `/cd <目录>` `/pwd` `/status` `/autoedit [on|off]` `/approve <id> allow-once|allow-always|allow-session|deny` `/chat` `/work` `/skills` `/help`；只在飞书里有的：`/web` `/detach` `/bind <绑定码>`
 
 自定义命令：设置 → 命令 → 「添加命令」，填命令名、说明和一段提示词，之后发 `/命令名 参数` 就会把这段提示词发给 agent（提示词里的 `$ARGUMENTS` 换成参数，没写就把参数接在后面）。按 agent 分开存，可以编辑、删除，也会同步到飞书指令面板。
 
@@ -144,6 +145,7 @@ agent-loft service install
 - 暴露到公网时，只通过 HTTPS 反向代理（比如 Lucky）或 Cloudflare Tunnel 访问，并把不在本机的反代 IP 加进 `web.trustedProxies`（只有从这些地址来的连接才采信 `X-Forwarded-*`）。不要直接把 8800 端口映射出去。局域网访问可以在 设置 → 系统 → 网络访问 里关掉。
 - 审批超时一律按拒绝处理。Codex 默认沙箱为 `workspace-write`，不会因为 `~/.codex/config.toml` 里配了 `never` 或 `danger-full-access` 就绕过审批。
 - agent 子进程拿不到本服务自己的凭据（`FEISHU_*`、`AGENT_LOFT_*` 等环境变量会被剔除）。
+- 技能存在 `data/skills/`：技能本体在 `files/<技能 id>/`，每个人装了哪些、变量的值在 `users/<用户 id>.json`（0600）。普通变量注入到会话环境里，agent 能读到；受保护的密钥 agent 看不到值，但和多用户一样不是安全边界——工作模式下 agent 能直接读这些文件。别人分享的技能会在你的会话里照着执行，装之前在技能页点开看一眼它要做什么、要哪些变量。
 - 记忆存在 `data/memory/<用户 id>.json`，聊天记录索引在 `data/history/<用户 id>.jsonl`。记给谁由 agent-loft 在拉起记忆工具时定死（工具参数里没有用户），模型想写别人的记忆也写不了；但和多用户一样不是安全边界：工作模式下 agent 能读到这些文件。聊天模式没有读写本机文件的工具，网页里的提示注入也骗不走本机文件。
 
 ## 结构
@@ -163,11 +165,14 @@ src/
     chat-mode.ts   聊天模式告诉 agent 的话（Claude 换系统提示，Codex 附在消息后面）
     tasks.ts       定时任务的存储（按人隔离）；task-schedule.ts 频率和 cron；task-prompt.ts 每次运行附给 agent 的说明和静默暗号
     task-runner.ts 定时任务的调度：到点核对主人和对话、送进对话、记下结果
-    tasks-bridge.ts 定时任务工具在主进程这头：核对签名、弹授权卡、增删改（tasks-mcp.ts 定怎么拉起）
+    tasks-bridge.ts 定时任务工具在主进程这头：核对签名、弹授权卡、增删改（tasks-mcp.ts 定怎么拉起）；技能工具也走这条通道
+    skills.ts      技能的存储：可见性、安装、停用、变量和受保护密钥确认过的地址；zip.ts 解技能包
+    skill-runtime.ts 技能怎么交给 agent：Claude 的插件目录和成员白名单、Codex 的清单、@ 技能、机器上原有的技能
+    skills-bridge.ts 技能工具在主进程这头：建 / 改技能（弹授权卡）、skill_request 代发带密钥的请求
     pairing.ts uploads.ts commands.ts …
   mcp/
     memory-server.ts 记忆工具（remember / forget / search_past_chats）的 stdio MCP 服务，两个 agent 共用
-    tasks-server.ts  定时任务工具的 stdio MCP 服务：只传话，经 unix socket 转给主进程
+    tasks-server.ts  定时任务工具的 stdio MCP 服务：只传话，经 unix socket 转给主进程；AGENT_LOFT_TOOLSET=skills 时是技能工具
   agents/
     claude/        Claude Agent SDK 驱动
     codex/         codex app-server 驱动

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-loft",
-  "version": "0.2.31",
+  "version": "0.2.32",
   "type": "module",
   "description": "多个 agent 的工作台：把本机 Claude Code / Codex 放到一处统一管理，用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
   "keywords": [

package/src/agents/claude/driver.ts

@@ -31,7 +31,7 @@ import type {
 import { describeUsage, readUsage, toQuota } from "./account.js";
 import { cachedProbe, withProbe } from "./probe.js";
 import { diagnose } from "./errors.js";
-import { ClaudeSession, describeToolUse, summarize, toModelInfo } from "./session.js";
+import { claudeBuiltins, ClaudeSession, describeToolUse, summarize, toModelInfo } from "./session.js";
 
 /** 模型列表几乎不变，缓存 10 分钟；读失败抛给设置页，让它退回手填 */
 const readCatalog = cachedProbe(10 * 60_000, "模型列表", () => withProbe(async (q) => toModelInfo(await q.supportedModels())));
@@ -52,11 +52,15 @@ function readCommands(cwd: string): Promise<AgentCommand[]> {
       () =>
         withProbe(
           async (q) =>
-            (await q.supportedCommands()).map((c) => ({
-              name: c.name,
-              description: c.description,
-              ...(c.argumentHint ? { args: c.argumentHint } : {}),
-            })),
+            (await q.supportedCommands()).map((c) => {
+              if (c.builtin) claudeBuiltins.add(c.name);
+              return {
+                name: c.name,
+                description: c.description,
+                ...(c.argumentHint ? { args: c.argumentHint } : {}),
+                ...(c.builtin ? { builtin: true } : {}),
+              };
+            }),
           cwd,
         ),
       [] as AgentCommand[],

package/src/agents/claude/session.ts

@@ -16,7 +16,8 @@ import {
 import { agentEnvironment } from "../../core/agent-env.js";
 import { chatSystemPrompt } from "../../core/chat-mode.js";
 import { MEMORY_MCP_NAME, memoryMcpSpawn } from "../../core/memory-mcp.js";
-import { TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
+import { SKILLS_MCP_NAME, skillsMcpSpawn, TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
+import { PLUGIN_NAME, projectCommandNames } from "../../core/skill-runtime.js";
 import { describeAttachments, inlineTextBlocks, readTextAttachments } from "../../core/uploads.js";
 import type {
   AgentEvents,
@@ -130,6 +131,13 @@ function buildContent(input: UserInput, chat: boolean): string | ContentBlock[]
 const MEMORY_TOOLS = new Set(["remember", "forget", "search_past_chats"].map((t) => `mcp__${MEMORY_MCP_NAME}__${t}`));
 /** 定时任务工具：要用户确认的那几个由 agent-loft 自己弹卡（tasks-bridge.ts），这里不再问一遍 */
 const TASK_TOOLS = new Set(["list_tasks", "create_task", "update_task", "delete_task"].map((t) => `mcp__${TASKS_MCP_NAME}__${t}`));
+/** 技能工具：建、改技能前由 agent-loft 自己弹卡（skills-bridge.ts） */
+const SKILL_TOOLS = new Set(["list_skills", "get_skill", "create_skill", "update_skill", "skill_request"].map((t) => `mcp__${SKILLS_MCP_NAME}__${t}`));
+/**
+ * Claude Code 自带的命令和技能名（supportedCommands 里标了 builtin 的），driver 读命令表时顺手记下。
+ * 成员会话的技能白名单要带上它们；还没读到过就先不带（只少了 /simplify 这类自带技能）。
+ */
+export const claudeBuiltins = new Set<string>();
 /** 聊天模式的全部工具：只能联网，碰不到本机 */
 const CHAT_TOOLS = ["WebSearch", "WebFetch"];
 
@@ -152,7 +160,12 @@ export function modeOptions(opts: SessionOptions): Partial<Options> {
     ...(memory
       ? { [MEMORY_MCP_NAME]: { type: "stdio", ...memoryMcpSpawn(memory.userId, "claude", { search: !!memory.search, ...(memory.convKey ? { convKey: memory.convKey } : {}) }) } }
       : {}),
-    ...(opts.tasks ? { [TASKS_MCP_NAME]: { type: "stdio", ...tasksMcpSpawn(opts.tasks.userId, opts.tasks.convKey, "claude") } } : {}),
+    ...(opts.tasks
+      ? {
+          [TASKS_MCP_NAME]: { type: "stdio", ...tasksMcpSpawn(opts.tasks.userId, opts.tasks.convKey, "claude") },
+          [SKILLS_MCP_NAME]: { type: "stdio", ...skillsMcpSpawn(opts.tasks.userId, opts.tasks.convKey, "claude") },
+        }
+      : {}),
   };
   if (opts.mode === "chat") {
     return {
@@ -168,13 +181,24 @@ export function modeOptions(opts: SessionOptions): Partial<Options> {
   const switched = opts.announceMode
     ? "这条对话刚从「聊天模式」切到「工作模式」：之前聊天模式下不能执行命令、不能读写文件的限制已经解除，现在可以正常干活。不用为之前说做不到而道歉。"
     : "";
-  const append = [memory?.prompt, switched].filter(Boolean).join("\n\n");
+  const skills = opts.skills;
+  const append = [memory?.prompt, skills?.prompt, switched].filter(Boolean).join("\n\n");
   return {
     systemPrompt: { type: "preset", preset: "claude_code", ...(append ? { append } : {}), snapshot: false },
     ...(Object.keys(mcpServers).length ? { mcpServers } : {}),
+    ...(skills?.pluginDir ? { plugins: [{ type: "local" as const, path: skills.pluginDir, skipMcpDiscovery: true }] } : {}),
+    ...(skills && !skills.admin ? { skills: memberSkillAllowlist(skills, opts.cwd) } : {}),
   };
 }
 
+/**
+ * 成员会话能用的技能：agent-loft 里启用的、Claude Code 自带的、项目目录里的。机器上另外装的
+ * （~/.claude/skills、插件市场、claude.ai 同步的）不在里面：模型看不到，Skill 工具也调不了。
+ */
+function memberSkillAllowlist(skills: NonNullable<SessionOptions["skills"]>, cwd: string): string[] {
+  return [...new Set([...skills.list.map((s) => `${PLUGIN_NAME}:${s.name}`), ...claudeBuiltins, ...projectCommandNames(cwd)])];
+}
+
 export class ClaudeSession implements AgentSession {
   private queue = new AsyncQueue<SDKUserMessage>();
   private q: Query | null = null;
@@ -228,7 +252,8 @@ export class ClaudeSession implements AgentSession {
       prompt: input.stream(),
       options: {
         cwd: this.opts.cwd,
-        env: agentEnvironment(),
+        // 技能变量只在工作模式注入：聊天模式没有执行命令的工具，用不上
+        env: { ...agentEnvironment(), ...(this.opts.mode === "chat" ? {} : (this.opts.skills?.env ?? {})) },
         // 只能是 default 或 acceptEdits：bypassPermissions 会让 canUseTool 变成死代码。
         // acceptEdits 只放行工作目录（含附件目录）内的改文件，其它照样走 canUseTool
         permissionMode: this.opts.autoEdit ? "acceptEdits" : "default",
@@ -357,7 +382,7 @@ export class ClaudeSession implements AgentSession {
     // 自家的记忆工具，以及聊天模式下的联网工具：不问。
     // 不用 allowedTools 放行 —— SDK 会对每个会话打一条「canUseTool 被绕过」的警告
     if (MEMORY_TOOLS.has(toolName) && this.opts.memory) return { behavior: "allow", updatedInput: input };
-    if (TASK_TOOLS.has(toolName) && this.opts.tasks) return { behavior: "allow", updatedInput: input };
+    if ((TASK_TOOLS.has(toolName) || SKILL_TOOLS.has(toolName)) && this.opts.tasks) return { behavior: "allow", updatedInput: input };
     if (this.opts.mode === "chat" && CHAT_TOOLS.includes(toolName)) return { behavior: "allow", updatedInput: input };
 
     // 提问不是授权：它问的是「你选哪个」

package/src/agents/codex/session.ts

@@ -7,7 +7,8 @@ import { refusalFor, UnsupportedRequest } from "./refusals.js";
 import { config } from "../../core/config.js";
 import { contextBlock } from "../../core/chat-mode.js";
 import { MEMORY_MCP_NAME, memoryMcpSpawn } from "../../core/memory-mcp.js";
-import { TASK_TOOL_TIMEOUT_SEC, TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
+import { SKILLS_MCP_NAME, skillsMcpSpawn, TASK_TOOL_TIMEOUT_SEC, TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
+import { codexSkillLines } from "../../core/skill-runtime.js";
 import { describeAttachments, inlineTextBlocks, readTextAttachments } from "../../core/uploads.js";
 import type {
   AgentEvents,
@@ -131,7 +132,7 @@ export async function userMcpServers(): Promise<string[]> {
   if (userMcpCache && Date.now() - userMcpCache.at < 60_000) return userMcpCache.names;
   try {
     const res = await appServer.call<{ config?: { mcp_servers?: Record<string, unknown> | null } }>("config/read", {});
-    const names = Object.keys(res.config?.mcp_servers ?? {}).filter((n) => n !== MEMORY_MCP_NAME && n !== TASKS_MCP_NAME);
+    const names = Object.keys(res.config?.mcp_servers ?? {}).filter((n) => n !== MEMORY_MCP_NAME && n !== TASKS_MCP_NAME && n !== SKILLS_MCP_NAME);
     userMcpCache = { names, at: Date.now() };
     return names;
   } catch (err) {
@@ -368,13 +369,33 @@ export class CodexSession implements AgentSession {
     const mcp = {
       ...(memory ? { [`mcp_servers.${MEMORY_MCP_NAME}`]: memoryMcpSpawn(memory.userId, "codex", { search: !!memory.search, ...(memory.convKey ? { convKey: memory.convKey } : {}) }) } : {}),
       // 新建 / 修改任务要等用户点授权卡，Codex 默认 60 秒就算工具超时
-      ...(tasks ? { [`mcp_servers.${TASKS_MCP_NAME}`]: { ...tasksMcpSpawn(tasks.userId, tasks.convKey, "codex"), tool_timeout_sec: TASK_TOOL_TIMEOUT_SEC } } : {}),
+      ...(tasks
+        ? {
+            [`mcp_servers.${TASKS_MCP_NAME}`]: { ...tasksMcpSpawn(tasks.userId, tasks.convKey, "codex"), tool_timeout_sec: TASK_TOOL_TIMEOUT_SEC },
+            [`mcp_servers.${SKILLS_MCP_NAME}`]: { ...skillsMcpSpawn(tasks.userId, tasks.convKey, "codex"), tool_timeout_sec: TASK_TOOL_TIMEOUT_SEC },
+          }
+        : {}),
     };
     if (this.chat && !minimal) {
       const off = Object.fromEntries((await userMcpServers()).map((n) => [`mcp_servers.${n}.enabled`, false]));
       return { config: { ...CHAT_CONFIG, ...off, ...mcp } };
     }
-    return Object.keys(mcp).length ? { config: mcp } : {};
+    const work = { ...mcp, ...(minimal ? {} : this.skillConfig()) };
+    return Object.keys(work).length ? { config: work } : {};
+  }
+
+  /**
+   * 工作模式的技能设置：变量逐个写进 shell_environment_policy.set（只作用于这个 thread 里跑的命令，
+   * 一个个键写不会冲掉用户 config.toml 里本来设的）；成员关掉 Codex 自己的技能清单 ——
+   * 那里面是机器上装的技能，只给管理员。成员的技能走 contextBlock 里的清单。
+   */
+  private skillConfig(): Record<string, unknown> {
+    const skills = this.opts.skills;
+    if (!skills) return {};
+    return {
+      ...Object.fromEntries(Object.entries(skills.env).map(([k, v]) => [`shell_environment_policy.set.${k}`, v])),
+      ...(skills.admin ? {} : { "skills.include_instructions": false, "features.skill_search": false }),
+    };
   }
 
   /**
@@ -385,7 +406,7 @@ export class CodexSession implements AgentSession {
   private contextSent = false;
 
   private get contextPending(): boolean {
-    return !this.contextSent && (this.chat || !!this.opts.memory || !!this.opts.announceMode);
+    return !this.contextSent && (this.chat || !!this.opts.memory || !!this.opts.announceMode || codexSkillLines(this.opts.skills).length > 0);
   }
 
   private async openOnce(): Promise<string> {
@@ -503,7 +524,7 @@ export class CodexSession implements AgentSession {
     const note = input.attachments.length ? describeAttachments(input.attachments, inlined, chat) : "";
     const texts = chat ? inlineTextBlocks(input.attachments, textMap) : "";
     // 放在最后：Codex 拿第一条消息的开头当会话预览，不能被这段背景占掉
-    const context = this.contextPending ? contextBlock(chat ? "chat" : "work", this.opts.memory?.prompt, "联网搜索") : "";
+    const context = this.contextPending ? contextBlock(chat ? "chat" : "work", this.opts.memory?.prompt, "联网搜索", codexSkillLines(this.opts.skills)) : "";
     const text = [input.text, note, texts, context].filter(Boolean).join("\n\n");
     const images = input.attachments.filter((a) => a.kind === "image").map((a) => a.path);
     let startedOn: string | undefined;

package/src/channels/web/api.ts

@@ -63,6 +63,7 @@ import {
 import { canSeeConv, pushOwnedBy, sessionVisibleTo } from "./access.js";
 import { clientIp, cookies, HttpError, isHttps, readBody, readJsonBody, SECURITY_HEADERS, sendJson } from "./http.js";
 import { handleTasksApi } from "./tasks-api.js";
+import { handleSkillsApi } from "./skills-api.js";
 import { addSubscription, listSubscriptions, pushToAll, removeSubscription, removeSubscriptionsOf, vapidPublicKey } from "./push.js";
 
 export const COOKIE = "aim_session";
@@ -527,6 +528,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
 
   // ----- 定时任务 -----
   if (p.startsWith("/api/tasks") && (await handleTasksApi(req, res, p, user))) return;
+  if (p.startsWith("/api/skills") && (await handleSkillsApi(req, res, url, user))) return;
 
   // ----- 目录选择器：列工作区内的子目录 -----
   if (p === "/api/dirs" && method === "GET") {
@@ -844,6 +846,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         allowedAgents: hub.enabledAgents().map((d) => d.id),
         // 带 key 是输入框补全：只列 Web 能用的；不带是设置页排序，全列
         ...(conv ? { channel: "web" } : {}),
+        // 成员看不到机器上装的技能
+        ...(admin ? {} : { member: true }),
       });
       sendJson(res, 200, { commands });
       return;

package/src/channels/web/http.ts

@@ -89,8 +89,8 @@ export async function readBody(req: IncomingMessage, limit: number): Promise<Buf
   return Buffer.concat(chunks);
 }
 
-export async function readJsonBody<T = Record<string, unknown>>(req: IncomingMessage): Promise<T> {
-  const raw = await readBody(req, 1024 * 1024);
+export async function readJsonBody<T = Record<string, unknown>>(req: IncomingMessage, limit = 1024 * 1024): Promise<T> {
+  const raw = await readBody(req, limit);
   if (raw.length === 0) return {} as T;
   try {
     return JSON.parse(raw.toString("utf8")) as T;

package/src/channels/web/server.ts

@@ -14,6 +14,7 @@ import { GLOBAL_ALWAYS_DENIED, hub, type EventEnvelope } from "../../core/hub.js
 import { interactions, type Interaction } from "../../core/interactions.js";
 import { getConversation } from "../../core/store.js";
 import { taskEvents } from "../../core/tasks.js";
+import { skillEvents } from "../../core/skills.js";
 import { RUNNING_VERSION } from "../../core/upgrade.js";
 import type { Settlement } from "../../core/types.js";
 import { getUser, isAdmin, legacyOwnerId, type User } from "../../core/users.js";
@@ -186,6 +187,11 @@ function broadcastTasks(owner: string): void {
   for (const client of clients) if (client.user.id === owner) send(client, { t: "tasks" });
 }
 
+/** 技能变了：技能广场谁都可能在看，通知所有人重新拉（列表很小） */
+function broadcastSkills(): void {
+  for (const client of clients) send(client, { t: "skills" });
+}
+
 // ---------- 系统通知（Web Push） ----------
 
 /** 有页面正在前台看着这条会话：人就在眼前，不用推 */
@@ -485,6 +491,7 @@ export async function startWeb(): Promise<void> {
   interactions.on("updated", broadcastInteraction);
   interactions.on("settled", broadcastInteraction);
   taskEvents.on("changed", broadcastTasks);
+  skillEvents.on("changed", broadcastSkills);
 
   await listen(server, host, port);
   console.log(`[web] 已监听 http://${host}:${port}`);
@@ -515,6 +522,7 @@ export async function stopWeb(): Promise<void> {
   interactions.off("updated", broadcastInteraction);
   interactions.off("settled", broadcastInteraction);
   taskEvents.off("changed", broadcastTasks);
+  skillEvents.off("changed", broadcastSkills);
   if (heartbeat) clearInterval(heartbeat);
   for (const client of clients) client.ws.close(1001, "服务重启");
   clients.clear();

package/src/channels/web/skills-api.ts

@@ -0,0 +1,225 @@
+// 技能页面的接口：/api/skills。看得到的技能（自己的、公开的、指名给自己的）、安装 / 停用、变量、上传。
+// 只有作者能改；管理员能删别人公开或分享出来的（下架），但看不到、删不了别人私有的。
+import fs from "node:fs";
+import path from "node:path";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { machineSkills, mentionTargets } from "../../core/skill-runtime.js";
+import {
+  canDelete,
+  canSee,
+  createSkill,
+  declaredHosts,
+  deleteSkill,
+  getSkill,
+  installCount,
+  installSkill,
+  listAllSkills,
+  listFiles,
+  parseSkillMd,
+  prepareUpload,
+  readSkillFile,
+  readSkillMd,
+  setSkillEnabled,
+  setSkillVars,
+  SKILL_LIMITS,
+  updateSkill,
+  userPrefs,
+  type Skill,
+  type SkillInput,
+} from "../../core/skills.js";
+import { readZip } from "../../core/zip.js";
+import { getUser, isAdmin, listUsers, type User } from "../../core/users.js";
+import { HttpError, readJsonBody, sendJson } from "./http.js";
+
+function view(s: Skill, user: User) {
+  const prefs = userPrefs(user.id);
+  const mine = s.owner === user.id;
+  return {
+    id: s.id,
+    name: s.name,
+    description: s.description,
+    owner: s.owner,
+    ownerName: getUser(s.owner)?.name ?? "（已删除的用户）",
+    mine,
+    visibility: s.visibility,
+    // 分享给了谁只有作者看得到
+    ...(mine ? { sharedWith: s.sharedWith, installs: installCount(s.id) } : {}),
+    vars: s.vars,
+    source: s.source,
+    createdAt: s.createdAt,
+    updatedAt: s.updatedAt,
+    installed: mine || prefs.installed.includes(s.id),
+    enabled: !prefs.disabled.includes(s.id),
+    canDelete: canDelete({ id: user.id, role: user.role }, s),
+  };
+}
+
+/**
+ * 变量：值按名字存；密钥（任何一个看得到的技能把它标成密钥）不回显，只说填没填。
+ * 受保护的密钥再带上确认过的地址（hosts），作者后来加了没确认过的地址就列在 pending 里。
+ */
+function varsView(user: User, skills: Skill[]) {
+  const secret = new Set(skills.flatMap((s) => s.vars.filter((v) => v.secret).map((v) => v.name)));
+  const prefs = userPrefs(user.id);
+  const mineOrInstalled = skills.filter((s) => s.owner === user.id || prefs.installed.includes(s.id));
+  return Object.fromEntries(
+    Object.entries(prefs.vars).map(([k, v]) => {
+      const declared = declaredHosts(mineOrInstalled, k);
+      const approved = prefs.approved[k] ?? [];
+      const pending = declared.filter((h) => !approved.includes(h));
+      return [
+        k,
+        {
+          set: true,
+          ...(secret.has(k) ? {} : { value: v }),
+          ...(declared.length ? { hosts: approved } : {}),
+          ...(pending.length ? { pending } : {}),
+        },
+      ];
+    }),
+  );
+}
+
+type UploadBody = { zip?: string; files?: { path?: string; data?: string }[] };
+
+/** 上传：zip（.zip / .skill）或者一堆文件（选文件夹 / 单个 SKILL.md），内容都是 base64 */
+function uploadOf(raw: UploadBody | undefined): ReturnType<typeof prepareUpload> | undefined {
+  if (!raw) return undefined;
+  if (typeof raw.zip === "string") {
+    const entries = readZip(Buffer.from(raw.zip, "base64"), SKILL_LIMITS.totalBytes * 2, SKILL_LIMITS.files * 2);
+    return prepareUpload(entries);
+  }
+  if (Array.isArray(raw.files)) {
+    if (raw.files.length > SKILL_LIMITS.files * 2) throw new Error(`文件太多（最多 ${SKILL_LIMITS.files} 个）`);
+    return prepareUpload(raw.files.map((f) => ({ path: String(f.path ?? ""), data: Buffer.from(String(f.data ?? ""), "base64") })));
+  }
+  throw new Error("上传的内容不对");
+}
+
+const bad = (err: unknown) => (err instanceof HttpError ? err : new HttpError(400, err instanceof Error ? err.message : String(err)));
+
+/** 处理了就返回 true */
+export async function handleSkillsApi(req: IncomingMessage, res: ServerResponse, url: URL, user: User): Promise<boolean> {
+  const method = req.method ?? "GET";
+  const p = url.pathname;
+  const viewer = { id: user.id, role: user.role };
+
+  if (p === "/api/skills" && method === "GET") {
+    const visible = listAllSkills().filter((s) => canSee(viewer, s));
+    sendJson(res, 200, {
+      skills: visible.map((s) => view(s, user)),
+      vars: varsView(user, visible),
+      // 分享给谁：列出其他还能登录的用户
+      users: listUsers()
+        .filter((u) => !u.disabled && u.id !== user.id)
+        .map((u) => ({ id: u.id, name: u.name })),
+      ...(isAdmin(user) ? { machine: machineSkills().map((m) => ({ name: m.name, description: m.description, dir: m.dir, agents: m.agents })) } : {}),
+      limits: SKILL_LIMITS,
+    });
+    return true;
+  }
+
+  // 输入框 @ 的补全：自己能用的（管理员加上机器上原有的）
+  if (p === "/api/skills/mention" && method === "GET") {
+    sendJson(res, 200, { skills: mentionTargets(user.id).map((t) => ({ name: t.name, description: t.description, kind: t.kind })) });
+    return true;
+  }
+
+  // 管理员看机器上原有技能的 SKILL.md
+  if (p === "/api/skills/machine" && method === "GET") {
+    if (!isAdmin(user)) throw new HttpError(403, "只有管理员能看机器上的技能");
+    const m = machineSkills().find((x) => x.name === url.searchParams.get("name"));
+    if (!m) throw new HttpError(404, "没有这个技能");
+    let md = "";
+    try {
+      md = fs.readFileSync(path.join(m.dir, "SKILL.md"), "utf8");
+    } catch {
+      md = "（读不到 SKILL.md）";
+    }
+    sendJson(res, 200, { ...m, skillMd: md });
+    return true;
+  }
+
+  if (p === "/api/skills/vars" && method === "PUT") {
+    const body = await readJsonBody<{ values?: Record<string, unknown>; approve?: unknown }>(req);
+    try {
+      setSkillVars(user.id, body.values ?? {}, Array.isArray(body.approve) ? body.approve.map(String) : []);
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, { vars: varsView(user, listAllSkills().filter((s) => canSee(viewer, s))) });
+    return true;
+  }
+
+  if (p === "/api/skills" && method === "POST") {
+    const body = await readJsonBody<SkillInput & { upload?: UploadBody }>(req, 16 * 1024 * 1024);
+    let skill: Skill;
+    try {
+      const upload = uploadOf(body.upload);
+      const { upload: _u, ...input } = body;
+      skill = createSkill(user.id, input, upload ? "upload" : "manual", upload);
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, view(skill, user));
+    return true;
+  }
+
+  const m = /^\/api\/skills\/(s_[a-f0-9]+)(?:\/(install|enable|file))?$/.exec(p);
+  if (!m) return false;
+  const skill = getSkill(m[1]!);
+  if (!skill || !canSee(viewer, skill)) throw new HttpError(404, "这个技能不存在");
+
+  if (!m[2] && method === "GET") {
+    const md = parseSkillMd(readSkillMd(skill.id));
+    sendJson(res, 200, { ...view(skill, user), body: md.body, extra: md.extra, files: listFiles(skill.id) });
+    return true;
+  }
+  if (m[2] === "file" && method === "GET") {
+    const data = readSkillFile(skill.id, url.searchParams.get("path") ?? "");
+    if (!data) throw new HttpError(404, "没有这个文件");
+    // 只当文本看：二进制的给个提示
+    const text = data.includes(0) ? null : data.toString("utf8");
+    sendJson(res, 200, { text, size: data.length });
+    return true;
+  }
+  if (m[2] === "install" && method === "POST") {
+    const body = await readJsonBody<{ on?: boolean }>(req);
+    try {
+      installSkill(user.id, skill.id, body.on !== false);
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, view(skill, user));
+    return true;
+  }
+  if (m[2] === "enable" && method === "POST") {
+    const body = await readJsonBody<{ on?: boolean }>(req);
+    setSkillEnabled(user.id, skill.id, body.on !== false);
+    sendJson(res, 200, view(skill, user));
+    return true;
+  }
+  if (!m[2] && method === "PATCH") {
+    const body = await readJsonBody<SkillInput & { upload?: UploadBody }>(req, 16 * 1024 * 1024);
+    let updated: Skill;
+    try {
+      const upload = uploadOf(body.upload);
+      const { upload: _u, name: _n, ...input } = body;
+      updated = updateSkill(user.id, skill.id, input, upload ? { upload } : {});
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, view(updated, user));
+    return true;
+  }
+  if (!m[2] && method === "DELETE") {
+    try {
+      deleteSkill(viewer, skill.id);
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, { ok: true });
+    return true;
+  }
+  return false;
+}

package/src/core/chat-mode.ts

@@ -36,13 +36,13 @@ export function chatSystemPrompt(search: string, memory?: string): string {
 const OPEN = "<agent-loft-context>";
 const CLOSE = "</agent-loft-context>";
 
-/** Codex：附在会话进程第一条消息后面的背景（模式 + 记忆） */
-export function contextBlock(mode: "chat" | "work", memory: string | undefined, search: string): string {
+/** Codex：附在会话进程第一条消息后面的背景（模式 + 记忆 + 工作模式下的技能清单） */
+export function contextBlock(mode: "chat" | "work", memory: string | undefined, search: string, skills: string[] = []): string {
   const head =
     mode === "chat"
       ? ["当前是「聊天模式」，你作为用户的私人 AI 助手和他聊天：", ...chatRules(search)]
       : ["当前是「工作模式」：可以执行命令、读写文件，按平常的方式干活。之前如果说过「聊天模式下不能做」，那个限制已经解除。"];
-  return wrapContext([...head, ...(memory ? ["", memory] : [])]);
+  return wrapContext([...head, ...(memory ? ["", memory] : []), ...(mode === "work" && skills.length ? ["", ...skills] : [])]);
 }
 
 /** 包成 agent-loft 附上的背景：用户看不到（读历史、实时显示时都剥掉），agent 照着做 */

package/src/core/command-catalog.ts

@@ -24,6 +24,7 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "effort", args: "[程度]", description: "切换思考程度" },
   { name: "chat", description: "切到聊天模式：精简、只能联网搜索，每轮开销小很多" },
   { name: "work", description: "切到工作模式：agent 原装的全部能力" },
+  { name: "skills", description: "列出能用的技能（消息里写 @名字 点名使用）" },
   { name: "status", description: "查看当前会话、模型、目录、剩余额度" },
   { name: "sessions", args: "[all]", description: "列出历史会话，点按钮恢复；加 all 列所有目录" },
   { name: "resume", args: "<会话ID>", description: "恢复指定会话" },
@@ -42,7 +43,13 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
 ];
 
 /** agent 自己报上来的命令 */
-export type AgentCommand = { name: string; description: string; args?: string };
+export type AgentCommand = {
+  name: string;
+  description: string;
+  args?: string;
+  /** agent 自己带的（Claude Code 的 /compact、自带的技能），不是机器上另外装的 */
+  builtin?: boolean;
+};
 
 /**
  * 用户自定义命令。prompt 里的 $ARGUMENTS 换成命令后面跟的参数；

package/src/core/commands.ts

@@ -20,6 +20,7 @@ export type ParsedCommand =
   | { kind: "autoedit"; on?: boolean }
   | { kind: "mode"; mode: "chat" | "work" }
   | { kind: "help" }
+  | { kind: "skills" }
   /** 只发了一个「/」：列出可用命令 */
   | { kind: "commands" }
   | { kind: "approve"; requestId: string; decision: ApprovalDecision }
@@ -75,6 +76,8 @@ export function parseCommand(raw: string): ParsedCommand {
       return arg ? { kind: "chat", text } : { kind: "mode", mode: head.toLowerCase() as "chat" | "work" };
     case "help":
       return { kind: "help" };
+    case "skills":
+      return arg ? { kind: "chat", text } : { kind: "skills" };
     case "approve": {
       const [requestId, decision] = rest;
       if (!requestId || !decision) return { kind: "chat", text };