create-windy 0.8.3 → 0.10.0

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

@@ -0,0 +1,195 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { runInNewContext } from "node:vm";
+const Store = {
+  createSnapshotStore(initial: unknown) {
+    let value = initial;
+    const listeners = new Set<() => void>();
+    return {
+      getSnapshot: () => value,
+      set(next: unknown) {
+        value = next;
+        for (const listener of listeners) listener();
+      },
+      subscribe(listener: () => void) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    };
+  },
+};
+import * as Cordis from "@deepseek-ai/cordis";
+import type {
+  InputTriggerController,
+  InputTriggerSource,
+} from "@deepseek-ai/dsh-client-ui-input-trigger/client";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { bundledSkillDisplay } from "./index.mjs";
+type Element = { type: unknown; props: Record<string, unknown> };
+type Component = (props: Record<string, unknown>) => Element;
+function fixture(managementEnabled = false) {
+  const selected: string[] = [];
+  const entries = new Map<string, Component>();
+  const original = (props: Record<string, unknown>) => ({
+    type: "Original",
+    props,
+  });
+  runInNewContext(
+    readFileSync(new URL("./client.js", import.meta.url), "utf8"),
+    {
+      window: {
+        __WINDY_SKILL_DISPLAY__: bundledSkillDisplay,
+        __WINDY_SKILL_MANAGEMENT_ENABLED__: managementEnabled,
+        __ModuleLoader__: {
+          load(module: {
+            factory(require: (name: string) => object): {
+              apply(ctx: unknown): void;
+            };
+          }) {
+            module
+              .factory((name) =>
+                name === "react"
+                  ? {
+                      createElement: (
+                        type: unknown,
+                        props: Record<string, unknown>,
+                        ...children: unknown[]
+                      ) => ({ type, props: { ...props, children } }),
+                      useMemo: (fn: () => unknown) => fn(),
+                    }
+                  : { ReferenceChip: "ReferenceChip", Button: "Button" },
+              )
+              .apply({
+                layout: { selectPanel: (id: string) => selected.push(id) },
+                slots: {
+                  inject: (_name: string, callback: () => void) => callback(),
+                  subscribe: () => () => {},
+                  entries: (name: string) => [
+                    {
+                      component: original,
+                      options:
+                        name === "tool.call.toolview"
+                          ? { key: "skill" }
+                          : name === "conversation.user.text.node"
+                            ? { key: "skill" }
+                            : { id: "slash-menu" },
+                      locale: "skill",
+                      inject: () => ({ openSkill() {} }),
+                    },
+                  ],
+                  register: (
+                    options: { name: string; key?: string; id?: string },
+                    component: Component,
+                  ) => {
+                    entries.set(
+                      `${options.name}:${options.key || options.id}`,
+                      component,
+                    );
+                  },
+                },
+              });
+          },
+        },
+      },
+    },
+  );
+  return Object.assign(entries, { selected });
+}
+function upstreamController() {
+  const require = createRequire(import.meta.url);
+  let result!: { InputTriggerController: typeof InputTriggerController };
+  runInNewContext(
+    readFileSync(
+      require.resolve("@deepseek-ai/dsh-client-ui-input-trigger/client"),
+      "utf8",
+    ),
+    {
+      console,
+      AbortController,
+      setTimeout,
+      clearTimeout,
+      queueMicrotask,
+      window: {
+        __ModuleLoader__: {
+          load(module: {
+            factory(require: (name: string) => object): typeof result;
+          }) {
+            result = module.factory((name) =>
+              name === "@deepseek-ai/dsh-client-store"
+                ? Store
+                : name === "@deepseek-ai/cordis"
+                  ? Cordis
+                  : {},
+            );
+          },
+        },
+      },
+    },
+  );
+  return result.InputTriggerController;
+}
+test("Chinese menu display still selects the original skill ID through the actual upstream controller", async () => {
+  const Controller = upstreamController();
+  const picked: string[] = [];
+  const source: InputTriggerSource = {
+    name: "skill",
+    trigger: "/",
+    candidates: async () => [
+      { name: "windy-data-summary", description: "原始描述" },
+    ],
+    onPick: ({ candidate }) => {
+      picked.push(candidate.name);
+      return "handled";
+    },
+  };
+  const controller = new Controller({
+    actx: {} as never,
+    sessionId: SessionId("fixture"),
+    roster: { all: () => [source], sources: () => [source] },
+  });
+  controller.track("/", 1, { tier: "free" } as never, 1);
+  for (
+    let i = 0;
+    i < 10 && !controller.menu.getSnapshot().groups[0]?.items.length;
+    i++
+  )
+    await Promise.resolve();
+  const Menu = fixture().get("conversation.input.overlay:slash-menu")!;
+  const rendered = Menu({
+    menu: controller.menu,
+    onPick: (name: string, index: number) => controller.pick(name, index),
+  });
+  const displayMenu = rendered.props.menu as typeof controller.menu;
+  expect(displayMenu.getSnapshot().groups[0]!.items[0]!.name).toBe("数据汇总");
+  expect(controller.menu.getSnapshot().groups[0]!.items[0]!.name).toBe(
+    "windy-data-summary",
+  );
+  (rendered.props.onPick as (name: string, index: number) => void)("skill", 0);
+  expect(picked).toEqual(["windy-data-summary"]);
+  controller.dispose();
+});
+test("skill call and reference labels are Chinese without changing stored arguments or preview identity", () => {
+  const entries = fixture();
+  const argsRaw = JSON.stringify({ name: "windy-data-summary" });
+  const original = Object.freeze({ call: Object.freeze({ argsRaw }) });
+  const row = entries.get("tool.call.toolview:skill")!({ block: original });
+  expect(
+    JSON.parse((row.props.block as typeof original).call.argsRaw).name,
+  ).toBe("数据汇总");
+  expect(original.call.argsRaw).toBe(argsRaw);
+  const opened: string[] = [];
+  const reference = entries.get("conversation.user.text.node:skill")!({
+    node: { data: { name: "windy-data-summary" } },
+    interactive: true,
+    openSkill: (name: string) => opened.push(name),
+  });
+  expect(reference.props.label).toBe("数据汇总");
+  (reference.props.onActivate as () => void)();
+  expect(opened).toEqual(["windy-data-summary"]);
+});
+
+test("skill presentation never registers a duplicate settings entry", () => {
+  for (const enabled of [false, true])
+    expect(fixture(enabled).has("settings.section:windy-skills")).toBe(false);
+});

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

@@ -0,0 +1,9 @@
+export const bundledSkillDisplay: Record<
+  string,
+  { displayName: string; summary: string }
+>;
+export const name: string;
+export const inject: string[];
+export function apply(ctx: {
+  on(event: string, callback: (table: object[]) => void): void;
+}): void;

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

@@ -0,0 +1,30 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { skillDocument } from "../bundle.mjs";
+export const name = "windy-skill-presentation";
+export const inject = ["webServer"];
+const root = new URL("../../skills/", import.meta.url);
+export const bundledSkillDisplay = Object.fromEntries(
+  readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => {
+      const meta = skillDocument(
+        readFileSync(new URL(`${entry.name}/SKILL.md`, root), "utf8"),
+      );
+      return [
+        meta.name,
+        {
+          displayName: meta.displayName || "内置技能",
+          summary: meta.description.split(/[。\n]/)[0].slice(0, 44),
+        },
+      ];
+    }),
+);
+export function apply(ctx) {
+  ctx.on("webserver/index-inject", (table) =>
+    table.push({
+      kind: "global",
+      name: "__WINDY_SKILL_DISPLAY__",
+      value: bundledSkillDisplay,
+    }),
+  );
+}

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

@@ -0,0 +1,82 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import { FileSystemSkillProvider } from "@deepseek-ai/dsh-skill-filesystem";
+import { bundledSkillDisplay } from "./index.mjs";
+import { fixture, markdown } from "../test-fixture";
+const root = resolve(import.meta.dir, "../../skills");
+test("all bundled skills preserve official invocation IDs and expose validated Chinese frontmatter metadata", async () => {
+  const provider = new FileSystemSkillProvider(
+    new Context(),
+    { signal: new AbortController().signal, invalidate() {} },
+    { includeDefaultRoots: false, customSkillDirs: [root], watch: false },
+  );
+  try {
+    const observed = await provider.list({ cwd: root });
+    const candidates = Array.isArray(observed) ? observed : observed.candidates;
+    expect(candidates.map(({ name }) => name).sort()).toEqual([
+      "windy-data-summary",
+      "windy-extension-guide",
+      "windy-office",
+      "windy-skill-capture",
+      "windy-source-compare",
+    ]);
+    for (const candidate of candidates) {
+      const display = bundledSkillDisplay[candidate.name]!;
+      expect(display.displayName).toMatch(/[\u3400-\u9fff]/);
+      expect(display.summary.length).toBeLessThanOrEqual(44);
+      expect(candidate.metadata?.displayName).toBe(display.displayName);
+      expect(candidate.description).not.toMatch(/DSH|DeepSeek|Harness/);
+      const loaded = await provider.get(candidate, { cwd: root });
+      expect(loaded?.name).toBe(candidate.name);
+    }
+  } finally {
+    await provider.dispose();
+  }
+});
+test("personal skill metadata roundtrips while invalid display names are rejected and old skills remain compatible", async () => {
+  const f = await fixture();
+  const raw = markdown("my-skill").replace(
+    "description:",
+    "metadata:\n  displayName: 我的通用方法\ndescription:",
+  );
+  expect((await f.call({ action: "create", raw })).status).toBe(200);
+  const listed = await (await f.call({ action: "list" })).json();
+  expect(
+    listed.items.find((item: { name: string }) => item.name === "my-skill"),
+  ).toMatchObject({ name: "my-skill", displayName: "我的通用方法" });
+  expect(
+    (
+      await f.call({
+        action: "create",
+        raw: markdown("invalid-display").replace(
+          "description:",
+          "metadata:\n  displayName: [bad]\ndescription:",
+        ),
+      })
+    ).status,
+  ).toBe(400);
+  expect(
+    (await f.call({ action: "create", raw: markdown("old-skill") })).status,
+  ).toBe(200);
+  expect(
+    readFileSync(new URL("../client.js", import.meta.url), "utf8"),
+  ).toContain('label: () => "技能"');
+});
+
+test("only the enabled manager injects its native panel stylesheet", async () => {
+  const { apply } = await import("../index.mjs");
+  const f = await fixture();
+  const callbacks: ((table: unknown[]) => void)[] = [];
+  f.ctx.on = (_event, callback) => {
+    callbacks.push(callback);
+  };
+  apply(f.ctx, { ...f.config, enabled: false });
+  expect(callbacks).toHaveLength(0);
+  apply(f.ctx, f.config);
+  const table: unknown[] = [];
+  for (const callback of callbacks) callback(table);
+  expect(table).toHaveLength(1);
+  expect(table[0]).toMatchObject({ kind: "style" });
+});

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

@@ -0,0 +1,21 @@
+{
+  "name": "@southwind-ai/dsh-skill-presentation",
+  "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-skill",
+        "@deepseek-ai/dsh-client-ui-input-trigger",
+        "@deepseek-ai/dsh-client-ui-primitives"
+      ]
+    }
+  }
+}

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

@@ -0,0 +1,162 @@
+import { expect, test } from "bun:test";
+import { Window } from "happy-dom";
+import { readFile, readdir, mkdtemp, writeFile, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+import { runInNewContext } from "node:vm";
+type Node = unknown;
+type ReactFace = {
+  createElement(type: unknown, props?: object, ...children: Node[]): Node;
+  useSyncExternalStore(
+    subscribe: (listener: () => void) => () => void,
+    get: () => unknown,
+  ): unknown;
+};
+test("the shipped React mounts SkillMenu with a stable translated snapshot", async () => {
+  const window = new Window({ url: "http://localhost/agent/" });
+  window.document.write(
+    "<!doctype html><html><body><div id='root'></div></body></html>",
+  );
+  const saved = Object.fromEntries(
+    ["window", "document", "navigator"].map((key) => [
+      key,
+      Object.getOwnPropertyDescriptor(globalThis, key),
+    ]),
+  );
+  for (const [key, value] of Object.entries({
+    window,
+    document: window.document,
+    navigator: window.navigator,
+  }))
+    Object.defineProperty(globalThis, key, { configurable: true, value });
+  const temporary = await mkdtemp(join(tmpdir(), "windy-react-boot-"));
+  let root: { render(node: Node): void; unmount(): void } | undefined;
+  try {
+    const require = createRequire(import.meta.url);
+    const assets = join(
+      dirname(require.resolve("@deepseek-ai/dsh-web-frontend/package.json")),
+      "dist/assets",
+    );
+    const entry = (await readdir(assets)).find((file) =>
+      /^index-.*\.js$/.test(file),
+    )!;
+    const source = await readFile(join(assets, entry), "utf8");
+    const staticFactory = /function ([\w$]+)\(\)\{return\{react:/.exec(
+      source,
+    )?.[1];
+    const bootStart = /const [\w$]+=globalThis\.dshDesktopBoot/.exec(
+      source,
+    )?.index;
+    expect(staticFactory).toBeDefined();
+    expect(bootStart).toBeDefined();
+    // Expose the exact dependencies shipped by upstream, without running its networked app entrypoint.
+    const isolated =
+      source
+        .slice(0, bootStart)
+        .replace(/from"\.\//g, `from"${pathToFileURL(assets + "/").href}`) +
+      `\nexport default ${staticFactory}();`;
+    const modulePath = join(temporary, "shipped-runtime.mjs");
+    await writeFile(modulePath, isolated);
+    const modules = (await import(pathToFileURL(modulePath).href)).default;
+    const React = modules.react as ReactFace;
+    const entries = new Map<string, (props: Record<string, unknown>) => Node>();
+    const snapshot = {
+      groups: [{ source: "skill", items: [{ name: "windy-case-overview" }] }],
+    };
+    let renders = 0;
+    const listeners = new Set<() => void>();
+    const menu = {
+      getSnapshot: () => snapshot,
+      subscribe(listener: () => void) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    };
+    function Original(props: Record<string, unknown>) {
+      renders++;
+      const store = props.menu as typeof menu;
+      const value = React.useSyncExternalStore(
+        store.subscribe,
+        store.getSnapshot,
+      ) as typeof snapshot;
+      return React.createElement(
+        "p",
+        null as never,
+        value.groups[0]!.items[0]!.name,
+      );
+    }
+    runInNewContext(
+      await readFile(new URL("./client.js", import.meta.url), "utf8"),
+      {
+        window: {
+          __WINDY_SKILL_DISPLAY__: {
+            "windy-case-overview": { displayName: "案件概述" },
+          },
+          __ModuleLoader__: {
+            load(module: {
+              factory(require: (name: string) => unknown): {
+                apply(ctx: unknown): void;
+              };
+            }) {
+              module
+                .factory((name) => (name === "react" ? React : {}))
+                .apply({
+                  slots: {
+                    inject: (_slot: string, callback: () => void) => callback(),
+                    subscribe: () => () => {},
+                    entries: (slot: string) =>
+                      slot === "conversation.input.overlay"
+                        ? [
+                            {
+                              component: Original,
+                              options: { id: "slash-menu" },
+                            },
+                          ]
+                        : [],
+                    register: (
+                      options: { name: string; id: string },
+                      component: (props: Record<string, unknown>) => Node,
+                    ) => {
+                      entries.set(`${options.name}:${options.id}`, component);
+                      return () => {};
+                    },
+                  },
+                });
+            },
+          },
+        },
+      },
+    );
+    root = modules["react-dom/client"].createRoot(
+      window.document.getElementById("root"),
+    );
+    root!.render(
+      React.createElement(
+        entries.get("conversation.input.overlay:slash-menu"),
+        { menu },
+      ),
+    );
+    for (
+      let i = 0;
+      i < 30 && !window.document.body.textContent.includes("案件概述");
+      i++
+    )
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    expect(window.document.body.textContent).toContain("案件概述");
+    expect(snapshot.groups[0]!.items[0]!.name).toBe("windy-case-overview");
+    for (const listener of listeners) listener();
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(renders).toBeLessThan(5);
+  } finally {
+    root?.unmount();
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    await rm(temporary, { recursive: true, force: true });
+    for (const [key, descriptor] of Object.entries(saved)) {
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+      else Reflect.deleteProperty(globalThis, key);
+    }
+    await window.happyDOM.close();
+  }
+});