create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/plugins/drop-overlay/drop-overlay.test.ts

@@ -0,0 +1,199 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import { Window } from "happy-dom";
+import { apply } from "./index.mjs";
+
+const selector =
+  'body > div[role="status"]:has(> div > div[aria-hidden="true"] > svg[viewBox="0 0 115 84"])';
+const acceptingIcon = 'div[aria-hidden="true"] > svg > defs > clipPath';
+const css = readFileSync(new URL("style.css", import.meta.url), "utf8");
+
+/** Execute the installed upstream attachment plugin; only the React hook/portal
+ * host is simulated. Its overlay components, labels and drag listeners are real. */
+function fixture(
+  accepting: boolean,
+  limits: { count: number; size: string } | undefined = {
+    count: 3,
+    size: "8 MiB",
+  },
+) {
+  const window = new Window();
+  const document = window.document;
+  const cleanups: (() => void)[] = [];
+  const calls: unknown[][] = [];
+  const active: unknown[] = [];
+  const jsx = (type: unknown, props: unknown) => ({ type, props });
+  function render(value: unknown, svg = false): unknown {
+    if (value == null || typeof value === "boolean") return null;
+    if (Array.isArray(value)) return value.forEach((item) => render(item, svg));
+    const node = value as { type: unknown; props: Record<string, unknown> };
+    if (typeof node.type === "function")
+      return render(node.type(node.props), svg);
+    if (typeof node.type !== "string") return render(node.props.children, svg);
+    const element =
+      svg || node.type === "svg"
+        ? document.createElementNS("http://www.w3.org/2000/svg", node.type)
+        : document.createElement(node.type);
+    for (const [key, item] of Object.entries(node.props)) {
+      if (key === "children" || item == null || typeof item === "function")
+        continue;
+      element.setAttribute(key === "className" ? "class" : key, String(item));
+    }
+    const append = (child: unknown) => {
+      if (child == null || typeof child === "boolean") return;
+      if (Array.isArray(child)) return child.forEach(append);
+      if (typeof child === "string" || typeof child === "number")
+        element.append(String(child));
+      else {
+        const rendered = render(child, svg || node.type === "svg");
+        if (rendered) element.appendChild(rendered as never);
+      }
+    };
+    append(node.props.children);
+    return element;
+  }
+  let stateIndex = 0;
+  let composer!: (props: object) => unknown;
+  const require = (name: string) => {
+    if (name === "react/jsx-runtime")
+      return { jsx, jsxs: jsx, Fragment: Symbol("fragment") };
+    if (name === "react")
+      return {
+        useState: () => [
+          stateIndex++ === 0 ? null : true,
+          (value: unknown) => active.push(value),
+        ],
+        useRef: () => ({ current: 0 }),
+        useCallback: (value: unknown) => value,
+        useMemo: (callback: () => unknown) => callback(),
+        useEffect: (callback: () => (() => void) | undefined) => {
+          const cleanup = callback();
+          if (cleanup) cleanups.push(cleanup);
+        },
+      };
+    if (name === "react-dom")
+      return {
+        createPortal: (value: unknown) => {
+          document.body.appendChild(render(value) as never);
+          return null;
+        },
+      };
+    return {};
+  };
+  let plugin!: { apply(ctx: unknown): void };
+  Object.assign(window, {
+    __ModuleLoader__: {
+      load: (row: { factory: (loader: typeof require) => typeof plugin }) => {
+        plugin = row.factory(require);
+      },
+    },
+  });
+  runInNewContext(
+    readFileSync(
+      Bun.resolveSync(
+        "@deepseek-ai/dsh-client-ui-attachment/client",
+        import.meta.dir,
+      ),
+      "utf8",
+    ),
+    { window, document },
+  );
+  plugin.apply({
+    slots: {
+      registerFactory() {},
+      inject: (_name: string, callback: () => void) => callback(),
+      register: (row: { name: string }, component: typeof composer) => {
+        if (row.name === "conversation.input.attachments") composer = component;
+      },
+    },
+  });
+  const t = (key: string, args?: { count: number; size: string }) => {
+    if (key === "attachment.dropTitle") return "松手添加研判材料";
+    if (key === "attachment.dropBlocked") return "当前无法添加文件或图片";
+    if (key === "attachment.dropDesc")
+      return `图片限制：最多 ${args!.count} 张，每张 ${args!.size}`;
+    return key;
+  };
+  render(
+    composer({
+      attachments: [],
+      uploads: {},
+      canAcceptDrop: accepting,
+      dropLimits: limits,
+      onAddFiles: (...args: unknown[]) => calls.push(args),
+      onRemoveAttachment() {},
+      onRetryFile() {},
+      t,
+    }),
+  );
+  const file = new window.File(["synthetic"], "synthetic.pdf");
+  const transfer = {
+    types: ["Files"],
+    files: [file],
+    items: [{ kind: "file", webkitGetAsEntry: () => ({ isDirectory: false }) }],
+    dropEffect: "none",
+  };
+  function dispatch(type: string) {
+    const event = new window.Event(type, { bubbles: true, cancelable: true });
+    Object.defineProperty(event, "dataTransfer", { value: transfer });
+    document.dispatchEvent(event);
+  }
+  return {
+    window,
+    document,
+    calls,
+    active,
+    transfer,
+    file,
+    dispatch,
+    dispose: () => {
+      cleanups.forEach((cleanup) => cleanup());
+      window.close();
+    },
+  };
+}
+
+test.each([true, false])(
+  "real upstream overlay preserves accepting=%s title, limits and file-drop ownership",
+  (accepting) => {
+    const f = fixture(accepting);
+    try {
+      const overlay = f.document.querySelector(selector)!;
+      expect(overlay).not.toBeNull();
+      expect(Boolean(overlay.querySelector(acceptingIcon))).toBe(accepting);
+      if (accepting) {
+        expect(overlay.textContent).toContain("松手添加研判材料");
+        expect(overlay.textContent).toContain("最多 3 张，每张 8 MiB");
+      } else {
+        expect(overlay.textContent).toBe("当前无法添加文件或图片");
+      }
+      f.dispatch("dragenter");
+      f.dispatch("dragover");
+      expect(f.transfer.dropEffect).toBe(accepting ? "copy" : "none");
+      f.dispatch("drop");
+      expect(f.active.at(-1)).toBe(false);
+      expect(f.calls.length).toBe(accepting ? 1 : 0);
+      if (accepting) expect(f.calls[0]![0]).toEqual([f.file]);
+    } finally {
+      f.dispose();
+    }
+  },
+);
+
+test("style hook is presentation-only, scoped to real overlay semantics and honors reduced motion", () => {
+  let listener!: (table: unknown[]) => void;
+  apply({
+    on: (event: string, callback: typeof listener) => {
+      expect(event).toBe("webserver/index-inject");
+      listener = callback;
+    },
+  });
+  const table: unknown[] = [];
+  listener(table);
+  expect(table).toEqual([{ kind: "style", text: css }]);
+  expect(css.replace(/\s+/g, "")).toContain(selector.replace(/\s+/g, ""));
+  expect(css).toContain("pointer-events: none");
+  expect(css).toContain("prefers-reduced-motion: reduce");
+  expect(css).not.toMatch(/BInVoG|dropTitle|松手|preventDefault|onAddFiles/);
+});

package/template/apps/agent-server/plugins/drop-overlay/index.d.mts

@@ -0,0 +1,8 @@
+export const name: string;
+export const inject: string[];
+export function apply(ctx: {
+  on(
+    event: "webserver/index-inject",
+    handler: (table: unknown[]) => void,
+  ): unknown;
+}): void;

package/template/apps/agent-server/plugins/drop-overlay/index.mjs

@@ -0,0 +1,12 @@
+import { readFileSync } from "node:fs";
+
+export const name = "windy-drop-overlay";
+export const inject = ["webServer"];
+const style = readFileSync(new URL("./style.css", import.meta.url), "utf8");
+
+/** Presentation only; the upstream attachment owner keeps every drag/drop listener. */
+export function apply(ctx) {
+  ctx.on("webserver/index-inject", (table) => {
+    table.push({ kind: "style", text: style });
+  });
+}

package/template/apps/agent-server/plugins/drop-overlay/style.css

@@ -0,0 +1,102 @@
+/* alpha.3 body portal; never match generated CSS classes or translated copy. */
+body
+  > div[role="status"]:has(
+    > div > div[aria-hidden="true"] > svg[viewBox="0 0 115 84"]
+  ) {
+  padding: 32px;
+  box-sizing: border-box;
+  background: color-mix(in srgb, var(--dsw-alias-bg-base) 90%, transparent);
+  backdrop-filter: blur(4px);
+  pointer-events: none;
+  animation: none;
+
+  & > div {
+    width: 100%;
+    max-width: 512px;
+    box-sizing: border-box;
+    margin: 0;
+    padding: 40px;
+    border: 2px dashed var(--dsw-alias-brand-primary);
+    border-radius: 16px;
+    background: var(--dsw-alias-bg-layer-1);
+    color: var(--dsw-alias-label-primary);
+    box-shadow: 0 25px 50px -12px
+      color-mix(in srgb, var(--dsw-alias-label-primary) 25%, transparent);
+  }
+
+  & > div > div[aria-hidden="true"] {
+    width: 48px;
+    height: 48px;
+    color: var(--dsw-alias-brand-primary);
+
+    & > svg {
+      width: 48px;
+      height: 48px;
+    }
+  }
+
+  & > div > div:nth-child(2) {
+    margin-top: 16px;
+    font: inherit;
+    font-size: 18px;
+    font-weight: 600;
+    line-height: 1.5;
+  }
+
+  & > div > div:nth-child(3) {
+    margin-top: 8px;
+    font: inherit;
+    font-size: 14px;
+    line-height: 1.5;
+    color: var(--dsw-alias-label-secondary);
+    overflow-wrap: anywhere;
+  }
+
+  /* Only the accepting illustration has a clipping definition in alpha.3.
+     Blocked drops retain the upstream refusal icon and never animate. */
+  & > div > div[aria-hidden="true"]:has(> svg > defs > clipPath) {
+    animation: windy-material-upload-bounce 1s infinite;
+
+    &::before {
+      content: "";
+      display: block;
+      width: 48px;
+      height: 48px;
+      background: currentColor;
+      /* Lucide cloud-upload, ISC; same icon family as the shared Vue overlay. */
+      mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M12 13v8'/%3E%3Cpath d='M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242'/%3E%3Cpath d='m8 17 4-4 4 4'/%3E%3C/svg%3E")
+        center / contain no-repeat;
+    }
+
+    & > svg {
+      display: none;
+    }
+  }
+
+  &:not(:has(> div > div[aria-hidden="true"] > svg > defs > clipPath)) > div {
+    border-color: var(--dsw-alias-border-l2);
+  }
+}
+
+@keyframes windy-material-upload-bounce {
+  0%,
+  100% {
+    transform: translateY(-25%);
+    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
+  }
+  50% {
+    transform: none;
+    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  body
+    > div[role="status"]:has(
+      > div > div[aria-hidden="true"] > svg[viewBox="0 0 115 84"]
+    )
+    > div
+    > div[aria-hidden="true"] {
+    animation: none;
+  }
+}

package/template/apps/agent-server/plugins/locale/client.js

@@ -0,0 +1,61 @@
+window.__ModuleLoader__.load({
+  id: "@southwind-ai/dsh-locale",
+  factory(require) {
+    const React = require("react");
+    function apply(ctx) {
+      ctx.effect(() => {
+        const removeLanguage = ctx.locale.addLanguage({
+          id: "zh-CN",
+          label: "简体中文",
+          fallback: "zh",
+        });
+        const removeCopy = ctx.locale.register("chat", "zh-CN", {
+          "chat.deepDiving": "正在处理",
+          "chat.deepDivingFor": "正在处理 · 已用时 {duration}",
+        });
+        const removeConversation = ctx.locale.register(
+          "conversation",
+          "zh-CN",
+          {
+            "attachment.dropTitle": "松手添加研判材料",
+            "placeholder.hero":
+              "描述案件线索、核查问题或研判目标，/ 使用指令，@ 引用材料",
+            "placeholder.default":
+              "描述案件研判任务，或输入 / 使用指令、@ 引用材料",
+            "placeholder.plan": "描述案件分析目标与核查范围，先制定研判计划",
+          },
+        );
+        const keepChinese = () => {
+          if (ctx.locale.getLocale().active !== "zh-CN")
+            ctx.locale.setLocale("zh-CN");
+        };
+        const stop = ctx.on("locale/change", keepChinese);
+        keepChinese();
+        return () => {
+          stop();
+          removeCopy();
+          removeConversation();
+          removeLanguage();
+        };
+      }, "windy-locale.product-copy");
+      ctx.slots.inject("settings.general.item", () =>
+        ctx.slots.register(
+          {
+            name: "settings.general.item",
+            id: "language",
+            priority: -100,
+            order: 0,
+          },
+          () =>
+            React.createElement(
+              "div",
+              { style: { display: "flex", justifyContent: "space-between" } },
+              React.createElement("span", null, "语言"),
+              React.createElement("span", null, "中文"),
+            ),
+        ),
+      );
+    }
+    return { inject: ["locale", "slots"], apply };
+  },
+});

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

@@ -0,0 +1,9 @@
+export const name: string;
+export const inject: string[];
+export const bootstrap: string;
+export function apply(ctx: {
+  on(
+    event: "webserver/index-inject",
+    callback: (table: unknown[]) => void,
+  ): void;
+}): void;

package/template/apps/agent-server/plugins/locale/index.mjs

@@ -0,0 +1,16 @@
+export const name = "windy-locale";
+export const inject = ["webServer"];
+
+// The upstream public shell bridge selects Chinese before the client mounts,
+// including on an English browser. The client policy also handles late settings.
+export const bootstrap = `window.__DSH_LOCALE__ = Object.freeze({
+  read: async () => ({ languages: ["zh-CN"], preference: "zh" }),
+  onChange() {}
+});
+document.documentElement.lang = "zh-CN";`;
+
+export function apply(ctx) {
+  ctx.on("webserver/index-inject", (table) => {
+    table.push({ kind: "script", placement: "head", text: bootstrap });
+  });
+}

package/template/apps/agent-server/plugins/locale/locale.test.ts

@@ -0,0 +1,217 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import { apply, bootstrap } from "./index.mjs";
+import { nativeProfile } from "../../native/profile.js";
+
+type Element = { type: string; props: unknown; children: unknown[] };
+type Row = { id: string; priority: number };
+type ClientContext = {
+  on(event: string, callback: () => void): () => void;
+  effect(callback: () => () => void, label: string): void;
+  locale: {
+    getLocale(): { active: string };
+    setLocale(value: string): void;
+    addLanguage(value: {
+      id: string;
+      label: string;
+      fallback: string;
+    }): () => void;
+    register(
+      namespace: string,
+      locale: string,
+      values: Record<string, string>,
+    ): () => void;
+  };
+  slots: {
+    inject(name: string, callback: () => void): void;
+    register(row: Row, component: () => Element): void;
+  };
+};
+type Plugin = {
+  factory(require: () => unknown): { apply(ctx: ClientContext): void };
+};
+
+test("Chinese initialization is independent of browser language", async () => {
+  const window = {} as { __DSH_LOCALE__: { read(): Promise<unknown> } };
+  const document = { documentElement: { lang: "en" } };
+  runInNewContext(bootstrap, { window, document });
+  expect(await window.__DSH_LOCALE__.read()).toEqual({
+    languages: ["zh-CN"],
+    preference: "zh",
+  });
+  expect(document.documentElement.lang).toBe("zh-CN");
+  let listener: (table: unknown[]) => void = () => {};
+  apply({
+    on: (_event: string, callback: typeof listener) => (listener = callback),
+  });
+  const rows: unknown[] = [];
+  listener(rows);
+  expect(rows).toEqual([
+    { kind: "script", placement: "head", text: bootstrap },
+  ]);
+});
+
+test("late English preference is corrected and the language row has no selector", () => {
+  let plugin: Plugin | undefined;
+  runInNewContext(
+    readFileSync(new URL("./client.js", import.meta.url), "utf8"),
+    {
+      window: {
+        __ModuleLoader__: { load: (value: Plugin) => (plugin = value) },
+      },
+    },
+  );
+  if (!plugin) throw new Error("Missing locale policy plugin");
+  const client = plugin.factory(() => ({
+    createElement: (type: string, props: unknown, ...children: unknown[]) => ({
+      type,
+      props,
+      children,
+    }),
+  }));
+  let active = "en";
+  let changed = () => {};
+  const registrations: { row: Row; rendered: Element }[] = [];
+  let writes = 0;
+  const effects: (() => void)[] = [];
+  let dictionary: Record<string, string> = {};
+  client.apply({
+    effect: (callback) => {
+      effects.push(callback());
+    },
+    on: (_event: string, callback: () => void) => {
+      changed = callback;
+      return () => {
+        changed = () => {};
+      };
+    },
+    locale: {
+      addLanguage: (value) => {
+        expect(value).toEqual({
+          id: "zh-CN",
+          label: "简体中文",
+          fallback: "zh",
+        });
+        return () => {};
+      },
+      register: (namespace, locale, values) => {
+        expect(["chat", "conversation"]).toContain(namespace);
+        expect(locale).toBe("zh-CN");
+        if (namespace === "chat") dictionary = values;
+        else expect(values["placeholder.hero"]).toContain("案件");
+        return () => {};
+      },
+      getLocale: () => ({ active }),
+      setLocale: (value: string) => {
+        active = value;
+        writes++;
+        changed();
+      },
+    },
+    slots: {
+      inject: (_name: string, callback: () => void) => callback(),
+      register: (row: Row, component: () => Element) =>
+        registrations.push({ row, rendered: component() }),
+    },
+  });
+  expect(active).toBe("zh-CN");
+  active = "en";
+  changed();
+  expect(active).toBe("zh-CN");
+  expect(writes).toBe(2);
+  expect(registrations[0].row).toMatchObject({
+    id: "language",
+    priority: -100,
+  });
+  expect(JSON.stringify(registrations[0].rendered)).toContain("中文");
+  expect(JSON.stringify(registrations[0].rendered)).not.toMatch(
+    /select|button|English/,
+  );
+  expect(registrations).toHaveLength(1);
+  expect(dictionary["chat.deepDiving"]).toBe("正在处理");
+  expect(dictionary["chat.deepDivingFor"].replace("{duration}", "5秒")).toBe(
+    "正在处理 · 已用时 5秒",
+  );
+  effects.reverse().forEach((dispose) => dispose());
+});
+
+test("the managed profile owns Chinese preference and locale policy", () => {
+  const rows = nativeProfile({
+    appRoot: "/app",
+    gateUrl: "http://localhost:8080/internal/boundary",
+    model: "test",
+    contextWindow: 32768,
+    maxOutputTokens: 4096,
+  });
+  expect(rows).toContainEqual({ id: "locale", config: { preference: "zh" } });
+  const inserted = rows.flatMap((row) => ("insert" in row ? row.insert : []));
+  expect(inserted).toContainEqual({
+    id: "windy-locale",
+    name: "/app/plugins/locale/index.mjs",
+  });
+});
+
+test("product copy uses the real locale fallback without replacing upstream dictionaries", () => {
+  type Locale = ClientContext["locale"] & {
+    bind(ns: string): (key: string, values?: Record<string, string>) => string;
+  };
+  let upstream!: { LocaleRuntime: new (ctx: { emit(): void }) => Locale };
+  const upstreamCode = readFileSync(
+    new URL(
+      "../../../../node_modules/@deepseek-ai/dsh-client-locale/lib/client.js",
+      import.meta.url,
+    ),
+    "utf8",
+  );
+  runInNewContext(upstreamCode, {
+    navigator: { languages: ["en"], language: "en" },
+    window: {
+      __ModuleLoader__: {
+        load: (definition: {
+          factory(require: () => object): typeof upstream;
+        }) => {
+          upstream = definition.factory(() => ({}));
+        },
+      },
+    },
+  });
+  const locale = new upstream.LocaleRuntime({ emit() {} });
+  locale.register("chat", "zh", {
+    "chat.deepDiving": "深度求索中",
+    "chat.deepDivingFor": "深度求索中，用时 {duration} ···",
+    "chat.stop": "停止",
+  });
+  let plugin!: Plugin;
+  runInNewContext(readFileSync(new URL("client.js", import.meta.url), "utf8"), {
+    window: {
+      __ModuleLoader__: {
+        load: (value: Plugin) => {
+          plugin = value;
+        },
+      },
+    },
+  });
+  const effects: (() => void)[] = [];
+  plugin
+    .factory(() => ({}))
+    .apply({
+      locale,
+      on: () => () => {},
+      effect: (callback) => {
+        effects.push(callback());
+      },
+      slots: { inject() {}, register() {} },
+    });
+  expect(locale.getLocale().active).toBe("zh-CN");
+  expect(locale.bind("chat")("chat.deepDivingFor", { duration: "5秒" })).toBe(
+    "正在处理 · 已用时 5秒",
+  );
+  expect(locale.bind("chat")("chat.stop")).toBe("停止");
+  expect(locale.bind("conversation")("attachment.dropTitle")).toBe(
+    "松手添加研判材料",
+  );
+  effects.reverse().forEach((dispose) => dispose());
+  locale.setLocale("zh");
+  expect(locale.bind("chat")("chat.deepDiving")).toBe("深度求索中");
+});

package/template/apps/agent-server/plugins/locale/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@southwind-ai/dsh-locale",
+  "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-locale"
+      ]
+    }
+  }
+}