create-windy 0.8.3 → 0.10.0

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

@@ -0,0 +1,110 @@
+import { expect, test } from "bun:test";
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import type { ClientModuleSystem } from "@deepseek-ai/dsh-client-modules/client";
+import type {
+  ClientBundleRegistration,
+  ClientModuleLoaderTarget,
+  ClientModuleSystemOptions,
+} from "@deepseek-ai/dsh-client-modules/client";
+
+test("the official client module system loads this plugin's editor and use chunks", async () => {
+  const require = createRequire(import.meta.url);
+  let Runtime!: {
+    ClientModuleSystem: new (
+      options: ClientModuleSystemOptions,
+    ) => ClientModuleSystem;
+  };
+  runInNewContext(
+    readFileSync(
+      require.resolve("@deepseek-ai/dsh-client-modules/client"),
+      "utf8",
+    ),
+    {
+      window: {
+        __ModuleLoader__: {
+          load(registration: ClientBundleRegistration) {
+            Runtime = registration.factory(
+              Object.assign(() => ({}), {
+                async: async () => ({}),
+                asset: (reference: string) => reference,
+              }),
+            ) as typeof Runtime;
+          },
+        },
+      },
+    },
+  );
+  let loadEditor!: () => Promise<{ default: unknown }>;
+  const id = "@southwind-ai/dsh-skill-library";
+  const target: ClientModuleLoaderTarget = {
+    mode: "queue",
+    pendingQueue: [],
+    load(registration) {
+      this.pendingQueue.push(registration);
+    },
+    create() {
+      throw new Error("constructor is used below");
+    },
+  };
+  const requested: string[] = [];
+  const modules = new Runtime.ClientModuleSystem({
+    manifest: {
+      rev: "fixture",
+      plugins: [],
+      modules: [
+        {
+          id,
+          url: `plugins/??${id}/client.js&rev=fixture`,
+          initialUrl: `plugins/??${id}/client.js&rev=fixture`,
+          rev: "fixture",
+          inject: [],
+          external: [],
+        },
+      ],
+    },
+    registrationTarget: target,
+    bootstrapModule: {
+      id: "@deepseek-ai/dsh-client-modules",
+      exports: Runtime,
+    },
+    staticModules: {
+      react: {
+        lazy(loader: typeof loadEditor) {
+          loadEditor = loader;
+          return "Editor";
+        },
+      },
+      "@deepseek-ai/dsh-client-ui-primitives": {},
+    },
+    async loadBundle(url) {
+      requested.push(url);
+      const chunk = /\/(client\.[a-z]+\.js)\?rev=fixture$/.exec(url)?.[1];
+      runInNewContext(
+        readFileSync(new URL(chunk || "client.js", import.meta.url), "utf8"),
+        {
+          window: { __ModuleLoader__: target },
+        },
+      );
+    },
+  });
+  const plugin = (await modules.import(id)) as {
+    useSkill(
+      ctx: unknown,
+      workspaceId: string,
+      item: { name: string },
+      signal: AbortSignal,
+    ): Promise<void>;
+  };
+  const editor = await loadEditor();
+  expect(typeof editor.default).toBe("function");
+  const form = await loadEditor();
+  expect(typeof form.default).toBe("function");
+  await expect(
+    plugin.useSkill({}, "", { name: "valid" }, new AbortController().signal),
+  ).rejects.toThrow("请先选择工作区");
+  expect(requested).toContain(`plugins/${id}/client.editor.js?rev=fixture`);
+  expect(requested).toContain(`plugins/${id}/client.use.js?rev=fixture`);
+  expect(requested).toContain(`plugins/${id}/client.form.js?rev=fixture`);
+});

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

@@ -0,0 +1,139 @@
+import { expect, test } from "bun:test";
+import { Window, type HTMLInputElement } 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";
+
+test("shipped React mounts guided fields, applies an explicit suggestion and saves composed Markdown", 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-skill-form-"));
+  let root: { render(node: unknown): 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 factory = /function ([\w$]+)\(\)\{return\{react:/.exec(source)?.[1];
+    const bootStart = /const [\w$]+=globalThis\.dshDesktopBoot/.exec(
+      source,
+    )?.index;
+    expect(factory).toBeDefined();
+    expect(bootStart).toBeDefined();
+    const modulePath = join(temporary, "shipped-runtime.mjs");
+    await writeFile(
+      modulePath,
+      source
+        .slice(0, bootStart)
+        .replace(/from"\.\//g, `from"${pathToFileURL(assets + "/").href}`) +
+        `\nexport default ${factory}();`,
+    );
+    const modules = (await import(pathToFileURL(modulePath).href)).default;
+    const React = modules.react as {
+      createElement(type: unknown, props: object): unknown;
+      useState<T>(initial: T): [T, (value: T) => void];
+    };
+    let Form: unknown;
+    runInNewContext(
+      await readFile(new URL("./client.form.js", import.meta.url), "utf8"),
+      {
+        window: {
+          __ModuleLoader__: {
+            load(module: {
+              factory(require: (name: string) => unknown): { default: unknown };
+            }) {
+              Form = module.factory((name) =>
+                name === "react" ? React : { Button: "button" },
+              ).default;
+            },
+          },
+        },
+      },
+    );
+    const generated = {
+      name: "timeline",
+      displayName: "材料时间线",
+      description: "整理事件时间与来源",
+      inputs: "用户选择的材料",
+      steps: "1. 确认范围。\n2. 核查来源。",
+      output: "事件表格",
+      constraints: "不补造事实",
+    };
+    const saves: string[] = [];
+    function App() {
+      const [editor, setEditor] = React.useState({
+        fields: {},
+        workflow: "整理时间线",
+        suggestion: generated,
+      });
+      return React.createElement(Form, {
+        editor,
+        setEditor,
+        busy: false,
+        save: (_event: unknown, raw: string) => saves.push(raw),
+      });
+    }
+    root = modules["react-dom/client"].createRoot(
+      window.document.getElementById("root"),
+    );
+    root!.render(React.createElement(App, {}));
+    const settle = async (check: () => boolean) => {
+      for (let i = 0; i < 40 && !check(); i++)
+        await new Promise((resolve) => setTimeout(resolve, 5));
+      expect(check()).toBe(true);
+    };
+    const query = (name: string) =>
+      window.document.querySelector(`[name="${name}"]`) as HTMLInputElement;
+    await settle(() => Boolean(query("name")));
+    expect(query("name").value).toBe("");
+    for (const label of window.document.querySelectorAll("label"))
+      expect(window.document.getElementById(label.htmlFor)).not.toBeNull();
+    const apply = [...window.document.querySelectorAll("button")].find(
+      (button) => button.textContent === "填入表单",
+    )!;
+    apply.click();
+    await settle(() => query("name").value === "timeline");
+    expect(query("steps").value).toBe(generated.steps);
+    const preview = window.document.querySelector("pre")!;
+    expect(preview.textContent).toContain('displayName: "材料时间线"');
+    window.document
+      .querySelector("form")!
+      .dispatchEvent(
+        new window.Event("submit", { bubbles: true, cancelable: true }),
+      );
+    await settle(() => saves.length === 1);
+    expect(saves[0]).toBe(preview.textContent);
+    expect(saves[0]).toContain("disable-model-invocation: true");
+  } 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();
+  }
+});

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

@@ -0,0 +1,261 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import { fixture } from "./test-fixture";
+
+type Fields = Record<string, string>;
+type Element = {
+  type: unknown;
+  props: Record<string, unknown>;
+  children: unknown[];
+};
+type Editor = {
+  fields: Fields;
+  workflow?: string;
+  suggestion?: Fields | null;
+  assistError?: string;
+};
+const fields: Fields = {
+  name: "material-timeline",
+  displayName: '材料：时间线 "核查"',
+  description: "用户需要梳理事件时使用：\n保留来源 # 不添加事实",
+  inputs: "用户主动选择的材料",
+  steps: "1. 确认材料。\n2. 提取时间与来源。",
+  output: "时间、事件、来源三列表格",
+  constraints: "不得补造事实。",
+};
+function loadForm() {
+  let form!: {
+    default(props: object): Element;
+    serialize(fields: Fields): string;
+    validate(fields: Fields): Fields;
+  };
+  let errors: Fields = {};
+  runInNewContext(
+    readFileSync(new URL("./client.form.js", import.meta.url), "utf8"),
+    {
+      window: {
+        __ModuleLoader__: {
+          load(module: {
+            factory(require: (name: string) => unknown): typeof form;
+          }) {
+            form = module.factory((name) =>
+              name === "react"
+                ? {
+                    createElement: (
+                      type: unknown,
+                      props: object,
+                      ...children: unknown[]
+                    ) => ({ type, props: props || {}, children }),
+                    Fragment: "Fragment",
+                    useState: () => [
+                      errors,
+                      (value: Fields | ((old: Fields) => Fields)) => {
+                        errors =
+                          typeof value === "function" ? value(errors) : value;
+                      },
+                    ],
+                  }
+                : { Button: "button" },
+            );
+          },
+        },
+      },
+    },
+  );
+  return form;
+}
+function elements(value: unknown): Element[] {
+  if (Array.isArray(value)) return value.flatMap(elements);
+  if (!value || typeof value !== "object" || !("type" in value)) return [];
+  const item = value as Element;
+  return [item, ...item.children.flatMap(elements)];
+}
+function button(tree: Element, label: string) {
+  return elements(tree).find(
+    (item) => item.type === "button" && item.children.includes(label),
+  )!;
+}
+test("form serializes quotes, YAML punctuation and multiline prose into a valid installed skill", async () => {
+  const form = loadForm(),
+    f = await fixture();
+  expect(form.validate(fields)).toEqual({});
+  const raw = form.serialize(fields);
+  expect(raw).toContain("disable-model-invocation: true");
+  expect((await f.call({ action: "create", raw })).status).toBe(200);
+  const saved = await (
+    await f.call({ action: "read", name: fields.name, source: "personal" })
+  ).json();
+  expect(saved.description).toBe(fields.description);
+  expect(saved.displayName).toBe(fields.displayName);
+  expect(saved.raw).toContain(fields.steps);
+  expect(saved.raw).toBe(raw);
+});
+test("validation rejects missing fields, whitespace, invalid identifiers and overlong values", () => {
+  const form = loadForm();
+  expect(Object.keys(form.validate({}))).toEqual([
+    "displayName",
+    "name",
+    "description",
+    "steps",
+    "output",
+  ]);
+  for (const name of [
+    "../escape",
+    "中文",
+    "has--gap",
+    "-start",
+    "end-",
+    "UpperCase",
+    " ",
+  ])
+    expect(form.validate({ ...fields, name }).name).toBeTruthy();
+  expect(form.validate({ ...fields, steps: " \n " }).steps).toBeTruthy();
+  expect(
+    form.validate({ ...fields, displayName: "bad\nname" }).displayName,
+  ).toBeTruthy();
+  expect(
+    form.validate({ ...fields, description: "x".repeat(2049) }).description,
+  ).toBeTruthy();
+});
+test("generated suggestions require explicit application and save uses the current form, not stale raw", () => {
+  const form = loadForm();
+  let editor: Editor = {
+    fields,
+    suggestion: { ...fields, name: "generated", displayName: "生成的技能" },
+  };
+  const saves: string[] = [];
+  const render = (busy = false) =>
+    form.default({
+      editor,
+      busy,
+      setEditor: (next: Editor) => {
+        editor = next;
+      },
+      save: (_event: unknown, raw: string) => saves.push(raw),
+    });
+  let tree = render();
+  expect(editor.fields.name).toBe("material-timeline");
+  (button(tree, "填入表单").props.onClick as () => void)();
+  expect(editor.fields.name).toBe("generated");
+  expect(editor.suggestion).toBeNull();
+  tree = render();
+  const input = elements(tree).find((item) => item.props.name === "steps")!;
+  (input.props.onChange as (event: { target: { value: string } }) => void)({
+    target: { value: "人工修改步骤" },
+  });
+  tree = render();
+  (tree.props.onSubmit as (event: object) => void)({ preventDefault() {} });
+  expect(saves[0]).toContain("人工修改步骤");
+  expect(saves[0]).toContain('name: "generated"');
+  expect(button(render(true), "保存技能").props.disabled).toBe(true);
+});
+test("invalid submit preserves input, announces the field error and focuses its control", () => {
+  const form = loadForm();
+  let saved = false,
+    focused = "";
+  const props = {
+    editor: { fields: { ...fields, steps: " " } },
+    busy: false,
+    save: () => {
+      saved = true;
+    },
+  };
+  const tree = form.default(props);
+  (tree.props.onSubmit as (event: object) => void)({
+    preventDefault() {},
+    currentTarget: {
+      elements: {
+        namedItem: (name: string) => ({
+          focus() {
+            focused = name;
+          },
+        }),
+      },
+    },
+  });
+  expect(saved).toBe(false);
+  expect(focused).toBe("steps");
+  const updated = elements(form.default(props));
+  expect(
+    updated.find((item) => item.props.name === "steps")!.props["aria-invalid"],
+  ).toBe(true);
+  expect(
+    updated.find((item) => item.props.id === "skill-steps-error")!.props.role,
+  ).toBe("alert");
+});
+test("draft failures and cancelled late responses never replace the user's fields", async () => {
+  let api!: {
+    generateDraft(
+      editor: Editor,
+      workspaceId: string,
+      setEditor: (value: Editor) => void,
+      signal: AbortSignal,
+    ): Promise<void>;
+  };
+  const controller = new AbortController();
+  let mode = "failure";
+  runInNewContext(
+    readFileSync(new URL("./client.request.js", import.meta.url), "utf8"),
+    {
+      URL,
+      document: { baseURI: "http://localhost/agent/" },
+      fetch: async (_url: URL, options: { body: string }) => {
+        expect(JSON.parse(options.body)).toEqual({
+          action: "draft",
+          workspaceId: "workspace",
+          workflow: "整理时间线",
+        });
+        if (mode === "failure")
+          return Response.json({ error: "模型暂时不可用" }, { status: 503 });
+        controller.abort();
+        return Response.json({ draft: { ...fields, name: "late" } });
+      },
+      window: {
+        __ModuleLoader__: {
+          load(module: { factory(): typeof api }) {
+            api = module.factory();
+          },
+        },
+      },
+    },
+  );
+  const editor = { fields, workflow: "整理时间线" },
+    writes: Editor[] = [];
+  await api.generateDraft(
+    editor,
+    "workspace",
+    (value) => writes.push(value),
+    controller.signal,
+  );
+  expect(writes.at(-1)?.assistError).toBe("模型暂时不可用");
+  expect(writes.at(-1)?.fields).toEqual(fields);
+  writes.length = 0;
+  mode = "cancel";
+  await api.generateDraft(
+    editor,
+    "workspace",
+    (value) => writes.push(value),
+    controller.signal,
+  );
+  expect(writes).toHaveLength(1);
+  expect(writes[0]?.suggestion).toBeNull();
+  expect(editor.fields.name).toBe("material-timeline");
+});
+
+test("generation can be cancelled while form editing and saving remain locked", () => {
+  const form = loadForm();
+  let cancelled = false;
+  const tree = form.default({
+    editor: { fields, generating: true },
+    busy: true,
+    closeEditor: () => {
+      cancelled = true;
+    },
+  });
+  expect(button(tree, "保存技能").props.disabled).toBe(true);
+  const cancel = button(tree, "取消生成");
+  expect(cancel.props.disabled).toBe(false);
+  (cancel.props.onClick as () => void)();
+  expect(cancelled).toBe(true);
+});