create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/plugins/skill-library/index.d.mts

@@ -0,0 +1,49 @@
+export interface SkillConfig {
+  enabled: boolean;
+  defaultSkillDir: string;
+  extraDefaultSkillDirs?: readonly string[];
+  draftModel?: string;
+  draftMaxTokens?: number;
+}
+export interface SkillContext {
+  tools: Pick<import("@deepseek-ai/dsh-tools").ToolRuntime, "register">;
+  userQuestions: Pick<
+    import("@deepseek-ai/dsh-user-questions").UserQuestionService,
+    "ask"
+  >;
+  workingDirectory: Pick<
+    import("@deepseek-ai/dsh-working-directory").WorkingDirectoryService,
+    "get"
+  >;
+  llm?: Pick<import("@deepseek-ai/dsh-llm").LlmRuntime, "prepareCall">;
+  connection: {
+    requestRejection(
+      request: Request | import("node:http").IncomingMessage,
+    ): number | undefined;
+  };
+  workspaceRegistry: {
+    get(id: string): { path: string } | undefined;
+    list(): { id: string; path: string }[];
+  };
+  sandboxPolicy: { workspaceRoot: string };
+  on(event: string, callback: (table: unknown[]) => void): void;
+  effect(callback: () => unknown, label?: string): void;
+  webServer: {
+    register(route: {
+      kind: "exact";
+      path: string;
+      handler(
+        request: import("node:http").IncomingMessage,
+        response: import("node:http").ServerResponse,
+      ): Promise<void>;
+    }): () => void;
+  };
+}
+export const name: string;
+export const inject: string[];
+export function apply(ctx: SkillContext, config: SkillConfig): void;
+export function skillResponse(
+  ctx: SkillContext,
+  config: SkillConfig,
+  request: Request,
+): Promise<Response>;

package/template/apps/agent-server/plugins/skill-library/index.mjs

@@ -0,0 +1,226 @@
+import { readFileSync } from "node:fs";
+import { generateSkillDraft } from "./draft.mjs";
+import { registerWorkflowTool } from "./workflow.mjs";
+import {
+  LIMITS,
+  fail,
+  decodeBundle,
+  markdownBundle,
+  encodeBundle,
+  skillName,
+} from "./bundle.mjs";
+import {
+  skillRoots,
+  listSkills,
+  readSkill,
+  installSkill,
+  updateSkill,
+  deleteSkill,
+} from "./storage.mjs";
+
+export const name = "windy-skill-library";
+export const inject = [
+  "webServer",
+  "connection",
+  "workspaceRegistry",
+  "sandboxPolicy",
+  "llm",
+  "tools",
+  "userQuestions",
+  "workingDirectory",
+];
+const styles = readFileSync(new URL("./style.css", import.meta.url), "utf8");
+export async function skillResponse(ctx, config, request) {
+  if (request.method !== "POST") return error(405, "请使用技能面板操作。");
+  const denied = ctx.connection.requestRejection(request);
+  if (denied) return error(denied, "身份已失效，请重新登录。");
+  if (!config.enabled) return error(403, "当前部署未开放个人技能管理。");
+  try {
+    const body = await request.json();
+    if (
+      !body ||
+      typeof body !== "object" ||
+      Array.isArray(body) ||
+      Object.keys(body).some(
+        (key) =>
+          ![
+            "action",
+            "workspaceId",
+            "name",
+            "source",
+            "raw",
+            "version",
+            "archive",
+            "confirmed",
+            "workflow",
+          ].includes(key),
+      )
+    )
+      fail("请求参数无效。");
+    if (body.action === "draft") {
+      const draft = await generateSkillDraft(ctx, config, body, request.signal);
+      request.signal.throwIfAborted();
+      return Response.json(
+        { draft },
+        {
+          headers: {
+            "cache-control": "no-store",
+            "x-windy-skill-draft-complete": "1",
+          },
+        },
+      );
+    }
+    return await skillRoots(ctx, config, body.workspaceId, async (roots) => {
+      request.signal.throwIfAborted();
+      if (body.action === "list")
+        return json({ items: await listSkills(roots) });
+      if (body.action === "import") {
+        if (
+          typeof body.archive !== "string" ||
+          body.archive.length > Math.ceil(LIMITS.archive / 3) * 4 ||
+          !/^[A-Za-z0-9+/]*={0,2}$/.test(body.archive)
+        )
+          fail("技能包无效或过大。", 413);
+        await installSkill(
+          roots,
+          decodeBundle(Buffer.from(body.archive, "base64")),
+        );
+        return json({ ok: true });
+      }
+      if (body.action === "create") {
+        await installSkill(roots, markdownBundle(body.raw));
+        return json({ ok: true });
+      }
+      const name = skillName(body.name),
+        root = roots[body.source];
+      if (!root || !["personal", "defaults"].includes(body.source))
+        fail("技能来源无效。");
+      if (body.action === "read") {
+        const item = await readSkill(root, name);
+        return json(item);
+      }
+      if (body.action === "export") {
+        const item = await readSkill(root, name, true),
+          bytes = encodeBundle(name, item.files);
+        if (bytes.length > LIMITS.archive)
+          fail("导出包超过 4 MiB，请精简技能附件。", 413);
+        const filename =
+          (item.displayName || name)
+            .replace(/[<>:"/\\|?*]/g, "-")
+            .replace(/[. ]+$/, "")
+            .trim() || name;
+        return new Response(bytes, {
+          headers: {
+            "content-type": "application/zip",
+            "content-disposition": `attachment; filename="${name}.zip"; filename*=UTF-8''${encodeURIComponent(filename + ".zip").replace(/['()*]/g, (char) => "%" + char.charCodeAt(0).toString(16).toUpperCase())}`,
+            "cache-control": "no-store",
+            "x-content-type-options": "nosniff",
+          },
+        });
+      }
+      if (body.source !== "personal")
+        fail("默认技能只读，请导出后更名导入个人副本。", 403);
+      if (body.action === "save")
+        await updateSkill(root, name, body.raw, body.version);
+      else if (body.action === "delete" && body.confirmed === true)
+        await deleteSkill(root, name, body.version);
+      else fail("操作无效。");
+      return json({ ok: true });
+    });
+  } catch (reason) {
+    return error(
+      reason.status ?? (reason.code === "ENOENT" ? 404 : 400),
+      reason.status ? reason.message : "技能操作失败，请刷新并检查文件格式。",
+    );
+  }
+}
+function json(value) {
+  return Response.json(value, { headers: { "cache-control": "no-store" } });
+}
+function error(status, message) {
+  return Response.json(
+    { error: message },
+    { status, headers: { "cache-control": "no-store" } },
+  );
+}
+export function apply(ctx, config) {
+  if (!config.enabled) return;
+  registerWorkflowTool(ctx, config);
+  const lifetime = new AbortController();
+  ctx.effect(() => () => lifetime.abort());
+  ctx.on("webserver/index-inject", (table) => {
+    table.push({ kind: "style", text: styles });
+  });
+  let tail = Promise.resolve();
+  ctx.effect(
+    () =>
+      ctx.webServer.register({
+        kind: "exact",
+        path: "/windy/skills",
+        async handler(incoming, outgoing) {
+          const denied = ctx.connection.requestRejection(incoming);
+          if (denied || incoming.method !== "POST") {
+            outgoing.writeHead(denied ?? 405);
+            outgoing.end();
+            return;
+          }
+          const controller = new AbortController(),
+            cancel = () => {
+              if (!outgoing.writableEnded) controller.abort();
+            };
+          outgoing.once("close", cancel);
+          try {
+            const chunks = [];
+            let size = 0;
+            for await (const chunk of incoming) {
+              if ((size += chunk.length) > 6 * 1024 * 1024) {
+                outgoing.writeHead(413);
+                outgoing.end();
+                return;
+              }
+              chunks.push(chunk);
+            }
+            const headers = new Headers();
+            for (const [key, value] of Object.entries(incoming.headers))
+              if (typeof value === "string") headers.set(key, value);
+            const request = new Request(
+              new URL(incoming.url, "http://dsh.internal"),
+              {
+                method: "POST",
+                headers,
+                body: Buffer.concat(chunks),
+                signal: AbortSignal.any([controller.signal, lifetime.signal]),
+              },
+            );
+            let draft = false;
+            try {
+              draft =
+                JSON.parse(Buffer.concat(chunks).toString("utf8"))?.action ===
+                "draft";
+            } catch {
+              /* The response validator handles malformed JSON. */
+            }
+            const resultPromise = draft
+              ? skillResponse(ctx, config, request)
+              : tail.then(() => skillResponse(ctx, config, request));
+            if (!draft)
+              tail = resultPromise.then(
+                () => undefined,
+                () => undefined,
+              );
+            const result = await resultPromise;
+            if (!outgoing.destroyed) {
+              outgoing.writeHead(
+                result.status,
+                Object.fromEntries(result.headers),
+              );
+              outgoing.end(Buffer.from(await result.arrayBuffer()));
+            }
+          } finally {
+            outgoing.off("close", cancel);
+          }
+        },
+      }),
+    "windy.skill-library",
+  );
+}

package/template/apps/agent-server/plugins/skill-library/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@southwind-ai/dsh-skill-library",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./index.mjs",
+    "./client": "./client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-ui-workspace",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  }
+}

package/template/apps/agent-server/plugins/skill-library/presentation/README.md

@@ -0,0 +1,27 @@
+# 技能中文展示
+
+展示名称来自随附技能的 frontmatter `metadata.displayName`，说明来自简短中文
+`description`。管理页、输入 `/` 后的技能列表、技能引用与历史技能调用摘要显示中文。
+原始 kebab-case `name` 继续用于加载、保存、导出、引用预览和模型调用。
+
+插件仅使用公开 slots 包装官方组件：`tool.call.toolview/skill`、
+`conversation.user.text.node/skill`、`conversation.input.overlay/slash-menu`。
+菜单 SnapshotStore 的展示副本不改变原 source、候选序号、原控制器或持久内容；测试使用
+真实官方 InputTriggerController 验证选中中文行后仍取得原始英文 ID。
+
+RC.2 的官方候选目录仍未贯通中文显示字段，不能将本次中文展示宣称为支持 `/文档`
+等中文关键词检索。当前可输入 `/` 选择中文行，也可按原 ID 调用。公开接口不提供读取或
+替换已有 source；不使用私有 roster、不复制输入控制器、不修改已安装依赖。详细源码
+证据、接口限制和最小上游补丁建议见 [UPSTREAM.md](UPSTREAM.md)。
+
+只读展示插件可独立于个人扩展管理开关加载；不会注册技能管理路由、创建个人技能目录或
+开放安装能力。个人管理入口与操作仍由原技能管理插件和原身份/路径校验负责。
+
+技能管理仅在侧栏「技能」提供入口。本展示插件不再注册 `settings.section`，也不需要读取
+管理开关的启动标志；管理开关继续由 Host profile 决定是否装配独立管理插件。
+
+展示包装同时等待 slot 声明与原始条目注册，使用公开 `slots.entries/subscribe` 跟踪原条目；
+上游条目晚到或替换时更新包装，忽略本插件自己的优先级条目，避免时序漏装或自引用。
+真实 Cordis + SlotRegistry 回归覆盖原条目先到、晚到与插件卸载；另用同版本官方 Web
+构建随附的真实 React/react-dom 在 happy-dom 挂载菜单，检查快照稳定性和原候选 ID。
+这些检查不等于完整浏览器会话启动或用户页面视觉验收。

package/template/apps/agent-server/plugins/skill-library/presentation/UPSTREAM.md

@@ -0,0 +1,54 @@
+# 中文技能检索：alpha.3 上游缺口与最小回馈
+
+当前实现完成中文展示与原 ID 选择，但不能声称 `/文档` 已能按显示名查到「文档处理」。
+输入 `/` 打开目录后选择中文行仍使用原 ID；按原 `/windy-case-overview` 调用仍兼容。
+
+## 已核实的接口限制
+
+依据安装的 `0.2.1-rc.2` 官方源码与公开声明：
+
+1. `@deepseek-ai/dsh-skill` 的 `SkillCandidate` 和 `SkillDefinition` 支持 frontmatter
+   `metadata`，但 `SkillSummary` 无 `displayName`，`toSummary()` 明确只投影原字段，
+   `list()` 因而丢失 `metadata.displayName`。
+2. `@deepseek-ai/dsh-api-session-controller` 的 `SkillEntry` 只提供
+   `name/path/description/whenToUse/modelInvocable`；`SessionSkillCatalog.list()` 再次明确
+   按这些字段构造 RPC 响应。仅在项目技能里增加 metadata 无法把 label 传到官方候选源。
+3. `@deepseek-ai/dsh-client-ui-skill` 的候选源先执行
+   `rankByName(skills, query)`，再构造候选，没有提供中文 `label`。官方 primitives 的
+   `rankByName` 已支持同时匹配 `name` 与 `label`，缺的是 label 的贯通。
+4. `InputTriggerServiceContract` 公开的只有 `registerSource(src)` 和
+   `sessionOf(actx)`，没有查找/替换已有 source 的方法。同一 trigger/name 重复注册会
+   抛错。Controller 的 roster 是私有依赖；访问 `live.sources` 或修改已有 service 方法
+   不属于公开扩展点。
+
+不能通过显示 SnapshotStore 包装增加真正的检索候选；也不能让菜单虚构候选或隐藏原控制器
+仍会选中的条目。这会导致键盘和指针选择不一致，或把 `/中文名` 错当执行 ID。
+
+## 最小上游补丁
+
+保持所有原 ID、权限和调用协议，在上游完成以下窄改动并发布：
+
+- `dsh-skill`：在 `SkillSummary` 增加可选只读 `displayName`。在 `toSummary()` 中从
+  candidate 的 `metadata.displayName` 提取经过类型、单行和长度校验的值，缺失则不填。
+- `dsh-api-session-controller`：在 `SkillEntry` 增加可选 `displayName`，在
+  `SessionSkillCatalog.list()` 投影该字段；同步生成的 typert Remote 类型/契约。
+- `dsh-client-ui-skill`：候选构造顺序改成以下逻辑，`onPick`、lexicon、reference codec
+  和模型序列化均保持原 ID：
+
+  ```ts
+  const named = skills.map((skill) => ({
+    ...skill,
+    ...(skill.displayName ? { label: skill.displayName } : {}),
+  }));
+  return rankByName(named, query).map((skill) => ({
+    name: skill.name,
+    ...(skill.label ? { label: skill.label } : {}),
+    description: skill.description,
+  }));
+  ```
+
+至少补充「中文 query 命中中文 label」「英文 ID 仍命中」「选择中文行仍提交英文 ID」
+「缺失/非法 displayName 保持兼容」「user-only/subagent/取消/冷会话行为不变」测试。
+
+项目现有展示包装可保留，也可在升级后收缩；升级前不修改 `node_modules`、不访问私有
+roster、不复制输入控制器。本文描述的是待回馈方案，尚未向上游提交或证明中文 query 可用。

package/template/apps/agent-server/plugins/skill-library/presentation/boot.test.ts

@@ -0,0 +1,150 @@
+import { expect, test } from "bun:test";
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import * as Cordis from "@deepseek-ai/cordis";
+import * as Slots from "@deepseek-ai/dsh-client-ui-slots";
+const require = createRequire(import.meta.url);
+type Plugin = { inject?: string[]; apply(ctx: unknown): void };
+function load(
+  path: string,
+  dependencies: Record<string, unknown>,
+  globals: Record<string, unknown> = {},
+) {
+  let result: unknown;
+  runInNewContext(readFileSync(path, "utf8"), {
+    console,
+    setTimeout,
+    clearTimeout,
+    queueMicrotask,
+    AbortController,
+    URL,
+    document: { baseURI: "http://localhost/agent/" },
+    fetch: async () => ({ ok: false }),
+    window: {
+      ...globals,
+      addEventListener() {},
+      removeEventListener() {},
+      __ModuleLoader__: {
+        load(module: { factory(require: (name: string) => unknown): unknown }) {
+          result = module.factory((name) => dependencies[name] || {});
+        },
+      },
+    },
+  });
+  return result;
+}
+const React = {
+  Component: class {},
+  createContext: () => ({}),
+  memo: (value: unknown) => value,
+  forwardRef: (value: unknown) => value,
+  createElement: (type: unknown, props: object) => ({ type, props }),
+};
+type Entry = {
+  component: unknown;
+  options: { key?: string; id?: string; priority?: number };
+};
+type Registry = {
+  register(options: object, component: unknown): () => void;
+  entriesOfSlot(name: string): Entry[];
+};
+for (const late of [false, true])
+  test(`official SlotRegistry applies presentation plugins with ${late ? "late" : "existing"} upstream entries`, async () => {
+    const renderer = load(
+      require.resolve("@deepseek-ai/dsh-client-ui-renderer/client"),
+      {
+        react: React,
+        "@deepseek-ai/cordis": Cordis,
+        "@deepseek-ai/dsh-client-ui-slots": Slots,
+      },
+    ) as { SlotRegistry: new (ctx: Cordis.Context) => unknown };
+    const ctx = new Cordis.Context();
+    const registryFiber = ctx.plugin(
+      renderer.SlotRegistry as never,
+      {} as never,
+    );
+    await registryFiber.await();
+    const registry = ctx.get("slots") as Registry;
+    registry.register(
+      {
+        name: "root",
+        children: {
+          "tool.call.toolview": { kind: "keyed", scope: "session" },
+          "conversation.chat.node": { kind: "keyed", scope: "session" },
+          "conversation.user.text.node": { kind: "keyed", scope: "session" },
+          "conversation.input.overlay": { kind: "list", scope: "session" },
+          "settings.section": { kind: "list", scope: "root" },
+        },
+      },
+      () => null,
+    );
+    const registerOriginals = () => {
+      for (const [name, key] of [
+        ["tool.call.toolview", "skill"],
+        ["conversation.chat.node", "context"],
+        ["conversation.user.text.node", "skill"],
+        ["conversation.input.overlay", "slash-menu"],
+      ]) {
+        registry.register(
+          {
+            name,
+            ...(name === "conversation.input.overlay" ? { id: key } : { key }),
+            locale: "skill",
+          },
+          () => null,
+        );
+      }
+    };
+    if (!late) registerOriginals();
+    ctx.provide("layout", { selectPanel() {} } as never);
+    const skill = load(
+      new URL("./client.js", import.meta.url).pathname,
+      { react: React },
+      { __WINDY_SKILL_MANAGEMENT_ENABLED__: true, __WINDY_SKILL_DISPLAY__: {} },
+    ) as Plugin;
+    const tool = load(
+      new URL("../../tool-presentation/client.js", import.meta.url).pathname,
+      { react: React },
+      {
+        __WINDY_TOOL_DISPLAY__: [
+          { name: "mcp__windy__query", displayName: "查询" },
+        ],
+      },
+    ) as Plugin;
+    const plugins = [
+      ctx.plugin(skill as never, {} as never),
+      ctx.plugin(tool as never, {} as never),
+    ];
+    try {
+      for (const plugin of plugins) await plugin.await();
+      if (late) registerOriginals();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      for (const [slot, key] of [
+        ["tool.call.toolview", "skill"],
+        ["conversation.chat.node", "context"],
+        ["conversation.user.text.node", "skill"],
+        ["conversation.input.overlay", "slash-menu"],
+      ]) {
+        expect(
+          registry
+            .entriesOfSlot(slot!)
+            .find((entry) => (entry.options.key || entry.options.id) === key)
+            ?.options.priority,
+        ).toBe(-100);
+      }
+      expect(
+        registry
+          .entriesOfSlot("settings.section")
+          .some((entry) => entry.options.id === "windy-skills"),
+      ).toBe(false);
+      expect(
+        registry
+          .entriesOfSlot("tool.call.toolview")
+          .some((entry) => entry.options.key === "mcp__windy__query"),
+      ).toBe(true);
+    } finally {
+      for (const plugin of plugins.reverse()) await plugin.dispose();
+      await registryFiber.dispose();
+    }
+  });

package/template/apps/agent-server/plugins/skill-library/presentation/client.js

@@ -0,0 +1,146 @@
+window.__ModuleLoader__.load({
+  id: "@southwind-ai/dsh-skill-presentation",
+  factory(require) {
+    const React = require("react"),
+      h = React.createElement;
+    const { ReferenceChip } = require("@deepseek-ai/dsh-client-ui-primitives");
+    const display = window.__WINDY_SKILL_DISPLAY__ || {};
+    const known = (name) => Object.hasOwn(display, name);
+    const title = (name) =>
+      known(name) ? display[name].displayName : "个人技能";
+    function translatedCall(block) {
+      const call = block.call || block;
+      try {
+        const args = JSON.parse(call.argsRaw);
+        if (typeof args.name !== "string" || !known(args.name)) return block;
+        const copy = {
+          ...call,
+          argsRaw: JSON.stringify({ ...args, name: title(args.name) }),
+        };
+        return block.call
+          ? { ...block, call: copy }
+          : { ...block, argsRaw: copy.argsRaw };
+      } catch {
+        return block;
+      }
+    }
+    function afterEntry(ctx, slot, key, install) {
+      ctx.slots.inject(slot, () => {
+        let original, dispose;
+        const reconcile = () => {
+          const next = ctx.slots
+            .entries(slot)
+            .find(
+              (entry) =>
+                (entry.options.key || entry.options.id) === key &&
+                entry.options.priority !== -100,
+            );
+          if (next === original) return;
+          dispose?.();
+          original = next;
+          dispose = next ? install(next) : undefined;
+        };
+        const off = ctx.slots.subscribe(slot, reconcile);
+        reconcile();
+        return () => {
+          off();
+          dispose?.();
+        };
+      });
+    }
+    function apply(ctx) {
+      afterEntry(ctx, "tool.call.toolview", "skill", (original) => {
+        return ctx.slots.register(
+          {
+            name: "tool.call.toolview",
+            key: "skill",
+            priority: -100,
+            locale: original.locale,
+          },
+          (props) =>
+            h(original.component, {
+              ...props,
+              block: translatedCall(props.block),
+            }),
+        );
+      });
+      afterEntry(ctx, "conversation.user.text.node", "skill", (original) => {
+        function SkillReference(props) {
+          const name = props.node.data.name;
+          if (!known(name)) return h(original.component, props);
+          return h(ReferenceChip, {
+            appearance: "skill",
+            label: title(name),
+            title: title(name),
+            ...(props.interactive
+              ? { onActivate: () => props.openSkill(name) }
+              : {}),
+          });
+        }
+        return ctx.slots.register(
+          {
+            name: "conversation.user.text.node",
+            key: "skill",
+            priority: -100,
+            inject: original.inject,
+          },
+          SkillReference,
+        );
+      });
+      afterEntry(
+        ctx,
+        "conversation.input.overlay",
+        "slash-menu",
+        (original) => {
+          function SkillMenu(props) {
+            const menu = React.useMemo(() => {
+              let previous, translated;
+              return {
+                ...props.menu,
+                getSnapshot() {
+                  const snapshot = props.menu.getSnapshot();
+                  if (snapshot === previous) return translated;
+                  previous = snapshot;
+                  translated = {
+                    ...snapshot,
+                    groups: snapshot.groups.map((group) =>
+                      group.source !== "skill"
+                        ? group
+                        : {
+                            ...group,
+                            items: group.items.map((item) =>
+                              known(item.name)
+                                ? {
+                                    ...item,
+                                    name: title(item.name),
+                                    label: title(item.name),
+                                    description: display[item.name].summary,
+                                  }
+                                : item,
+                            ),
+                          },
+                    ),
+                  };
+                  return translated;
+                },
+              };
+            }, [props.menu]);
+            return h(original.component, { ...props, menu });
+          }
+          return ctx.slots.register(
+            {
+              name: "conversation.input.overlay",
+              id: "slash-menu",
+              priority: -100,
+              order: 0,
+              locale: original.locale,
+              inject: original.inject,
+            },
+            SkillMenu,
+          );
+        },
+      );
+    }
+    return { inject: ["slots"], apply };
+  },
+});