create-windy 0.8.3 → 0.9.1

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

@@ -0,0 +1,126 @@
+window.__ModuleLoader__.load({
+  id: "@southwind-ai/dsh-downloads",
+  factory(require) {
+    const React = require("react");
+    function downloadUrl(actionUrl, base = document.baseURI) {
+      try {
+        const root = new URL(base),
+          action = new URL(actionUrl, root);
+        if (
+          action.origin !== root.origin ||
+          action.username ||
+          action.password ||
+          action.hash
+        )
+          return;
+        const routes = new Map([
+          [new URL("api/present.open", root).pathname, "present"],
+          [new URL("api/changes.open", root).pathname, "changes"],
+        ]);
+        const kind = routes.get(action.pathname);
+        const fields = ["sessionId", "seq", "index"];
+        if (
+          !kind ||
+          [...action.searchParams.keys()].some(
+            (key) => !fields.includes(key),
+          ) ||
+          fields.some((key) => action.searchParams.getAll(key).length !== 1)
+        )
+          return;
+        const id = action.searchParams.get("sessionId");
+        if (!/^[A-Za-z0-9_-]{1,128}$/.test(id ?? "")) return;
+        for (const key of ["seq", "index"])
+          if (
+            !/^(0|[1-9][0-9]*)$/.test(action.searchParams.get(key) ?? "") ||
+            !Number.isSafeInteger(Number(action.searchParams.get(key)))
+          )
+            return;
+        const target = new URL("windy/download", root);
+        target.searchParams.set("kind", kind);
+        for (const key of fields)
+          target.searchParams.set(key, action.searchParams.get(key));
+        return target.href;
+      } catch {
+        return;
+      }
+    }
+    function Download({ actionUrl }) {
+      const [busy, setBusy] = React.useState(false),
+        [error, setError] = React.useState("");
+      const active = React.useRef();
+      React.useEffect(() => () => active.current?.abort(), []);
+      const href = downloadUrl(actionUrl);
+      async function save(event) {
+        event.stopPropagation();
+        if (busy || !href) return;
+        setBusy(true);
+        setError("");
+        const controller = new AbortController();
+        active.current = controller;
+        try {
+          const response = await fetch(href, {
+            credentials: "same-origin",
+            cache: "no-store",
+            signal: controller.signal,
+          });
+          if (!response.ok) throw new Error();
+          const blob = await response.blob();
+          if (blob.size > 20 * 1024 * 1024) throw new Error();
+          const encoded = /filename\*=UTF-8''([^;]+)/i.exec(
+            response.headers.get("content-disposition") ?? "",
+          )?.[1];
+          const filename = encoded ? decodeURIComponent(encoded) : "artifact";
+          const url = URL.createObjectURL(blob),
+            link = document.createElement("a");
+          link.href = url;
+          link.download = filename;
+          link.rel = "noopener";
+          document.body.append(link);
+          link.click();
+          link.remove();
+          setTimeout(() => URL.revokeObjectURL(url), 1000);
+        } catch {
+          if (!controller.signal.aborted) setError("下载失败，请重试。");
+        } finally {
+          if (!controller.signal.aborted) setBusy(false);
+        }
+      }
+      return React.createElement(
+        "span",
+        { style: { display: "inline-flex", alignItems: "center", gap: "8px" } },
+        React.createElement(
+          "button",
+          {
+            type: "button",
+            disabled: busy || !href,
+            onClick: save,
+            style: {
+              cursor: busy ? "wait" : "pointer",
+              color: "var(--dsw-alias-link)",
+              background: "transparent",
+              border: "none",
+              padding: "4px 8px",
+              borderRadius: "8px",
+              font: "inherit",
+            },
+          },
+          busy ? "正在下载" : "下载",
+        ),
+        error ? React.createElement("span", { role: "alert" }, error) : null,
+      );
+    }
+    function apply(ctx) {
+      for (const slot of [
+        "deliverables.file.actions",
+        "deliverables.review.file.actions",
+      ])
+        ctx.slots.inject(slot, () =>
+          ctx.slots.register(
+            { name: slot, id: "windy-download", order: 100 },
+            Download,
+          ),
+        );
+    }
+    return { inject: ["slots"], apply, downloadUrl };
+  },
+});

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

@@ -0,0 +1,222 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdtemp, mkdir, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import { Context } from "@deepseek-ai/cordis";
+import { LocalFileSystem } from "@deepseek-ai/dsh-fs-local";
+import {
+  SessionId,
+  SessionSeq,
+  SessionLogOffset,
+} from "@deepseek-ai/dsh-session/types";
+import { ToolCallId } from "@deepseek-ai/dsh-llm/brand";
+import type { SessionEventWindow } from "@deepseek-ai/dsh-session-query";
+import type {} from "@deepseek-ai/dsh-tool-present/types";
+import type {} from "@deepseek-ai/dsh-workspace-changes/types";
+import {
+  downloadResponse,
+  MAX_DOWNLOAD_BYTES,
+  type DownloadContext,
+} from "./index.mjs";
+
+const cleanups: (() => Promise<unknown>)[] = [];
+afterEach(async () => {
+  for (const cleanup of cleanups.splice(0)) await cleanup();
+});
+async function fixture() {
+  const directory = await mkdtemp(join(tmpdir(), "windy-downloads-"));
+  cleanups.push(() => rm(directory, { recursive: true, force: true }));
+  const root = join(directory, "workspace");
+  await mkdir(root);
+  const context = new Context();
+  const fs = new LocalFileSystem(context, {
+    cwd: root,
+    diffBasisMaxBytes: 10485760,
+  });
+  const state = { path: "报告.docx", kind: "present", reads: 0 };
+  const header = {
+    id: SessionId("own-session"),
+    version: 4 as const,
+    createdAt: Date.now(),
+    isSeeded: false,
+    cwd: root,
+  };
+  const ctx: DownloadContext = {
+    connection: {
+      requestRejection: (request) =>
+        request.headers.get("cookie") === "native=owner" ? undefined : 401,
+    },
+    sessionQuery: {
+      readEvent: async (request): Promise<SessionEventWindow> => {
+        state.reads++;
+        if (request.sessionId !== "own-session")
+          throw new Error("SESSION_QUERY_SESSION_NOT_FOUND");
+        const target =
+          state.kind === "present"
+            ? {
+                seq: SessionSeq(2),
+                time: Date.now(),
+                type: "deliverables/presented" as const,
+                data: {
+                  turn: 1,
+                  callId: ToolCallId("present-call"),
+                  files: [{ path: state.path }],
+                },
+              }
+            : {
+                seq: SessionSeq(2),
+                time: Date.now(),
+                type: "workspace/changes" as const,
+                data: { turn: 1 },
+              };
+        return {
+          session: header,
+          inheritedEventCount: SessionLogOffset(0),
+          target,
+          events: [target],
+          startSeq: SessionSeq(2),
+          endSeq: SessionSeq(2),
+        };
+      },
+    },
+    fs,
+    sandboxPolicy: { workspaceRoot: root },
+    get: () => ({
+      summary: () => ({
+        turn: 1,
+        cwd: root,
+        files: [
+          { path: state.path, display: state.path, added: 0, deleted: 0 },
+        ],
+        total: 1,
+        added: 0,
+        deleted: 0,
+      }),
+    }),
+  };
+  const request = (
+    query = "kind=present&sessionId=own-session&seq=2&index=0",
+    cookie = "native=owner",
+  ) =>
+    new Request(`https://windy.test/windy/download?${query}`, {
+      headers: { cookie },
+    });
+  return { directory, root, ctx, state, request };
+}
+
+test("downloads a declared DOCX through public Session/FS APIs with Unicode filename", async () => {
+  const f = await fixture();
+  const bytes = new Uint8Array([80, 75, 3, 4, 7]);
+  await writeFile(join(f.root, f.state.path), bytes);
+  const response = await downloadResponse(f.ctx, f.request());
+  expect(response.status).toBe(200);
+  expect(new Uint8Array(await response.arrayBuffer())).toEqual(bytes);
+  expect(response.headers.get("content-disposition")).toContain(
+    "filename*=UTF-8''%E6%8A%A5%E5%91%8A.docx",
+  );
+  expect(response.headers.get("content-type")).toBe(
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  );
+});
+
+test("unknown session, missing cookie, undeclared index and path parameters fail closed", async () => {
+  const f = await fixture();
+  await writeFile(join(f.root, f.state.path), "artifact");
+  expect((await downloadResponse(f.ctx, f.request(undefined, ""))).status).toBe(
+    401,
+  );
+  expect(f.state.reads).toBe(0);
+  for (const query of [
+    "kind=present&sessionId=another-user&seq=2&index=0",
+    "kind=present&sessionId=own-session&seq=2&index=1",
+    "kind=present&sessionId=own-session&seq=3&index=0",
+  ])
+    expect((await downloadResponse(f.ctx, f.request(query))).status).toBe(404);
+  expect(
+    (
+      await downloadResponse(
+        f.ctx,
+        f.request(
+          "kind=present&sessionId=own-session&seq=2&index=0&path=/etc/passwd",
+        ),
+      )
+    ).status,
+  ).toBe(400);
+});
+
+test("outside-workspace declarations and symlinks cannot become downloads", async () => {
+  const f = await fixture();
+  const privateFile = join(f.directory, "private.docx");
+  await writeFile(privateFile, "private");
+  for (const path of [privateFile, "../private.docx"]) {
+    f.state.path = path;
+    expect((await downloadResponse(f.ctx, f.request())).status).toBe(404);
+  }
+  await symlink(privateFile, join(f.root, "link.docx"));
+  f.state.path = "link.docx";
+  expect((await downloadResponse(f.ctx, f.request())).status).toBe(404);
+});
+
+test("20 MiB cap and changed-file review coordinates retain the same containment", async () => {
+  const f = await fixture();
+  f.state.path = "summary.xlsx";
+  f.state.kind = "changes";
+  await writeFile(join(f.root, f.state.path), new Uint8Array([80, 75]));
+  const query = "kind=changes&sessionId=own-session&seq=2&index=0";
+  expect((await downloadResponse(f.ctx, f.request(query))).status).toBe(200);
+  await writeFile(
+    join(f.root, f.state.path),
+    new Uint8Array(MAX_DOWNLOAD_BYTES + 1),
+  );
+  expect((await downloadResponse(f.ctx, f.request(query))).status).toBe(413);
+});
+
+test("download client derives only event-coordinate URLs and registers both public slots", () => {
+  const source = readFileSync(new URL("./client.js", import.meta.url), "utf8");
+  let factory!: (require: (name: string) => unknown) => {
+    downloadUrl(action: string): string | undefined;
+    apply(ctx: unknown): void;
+  };
+  runInNewContext(source, {
+    URL,
+    document: { baseURI: "https://windy.test/agent/" },
+    window: {
+      __ModuleLoader__: {
+        load: (value: { factory: typeof factory }) => {
+          factory = value.factory;
+        },
+      },
+    },
+  });
+  const client = factory((name) => {
+    if (name !== "react") throw new Error("Private UI dependency");
+    return {};
+  });
+  expect(
+    client.downloadUrl("api/present.open?sessionId=own&seq=2&index=0"),
+  ).toBe(
+    "https://windy.test/agent/windy/download?kind=present&sessionId=own&seq=2&index=0",
+  );
+  for (const action of [
+    "https://evil.test/api/present.open?sessionId=own&seq=2&index=0",
+    "api/present.open?sessionId=own&seq=2&index=0&path=/etc/passwd",
+    "api/changes.open?sessionId=own&seq=-1&index=0",
+  ])
+    expect(client.downloadUrl(action)).toBeUndefined();
+  const slots: string[] = [];
+  client.apply({
+    slots: {
+      inject: (name: string, register: () => void) => {
+        slots.push(name);
+        register();
+      },
+      register: () => () => {},
+    },
+  });
+  expect(slots).toEqual([
+    "deliverables.file.actions",
+    "deliverables.review.file.actions",
+  ]);
+});

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

@@ -0,0 +1,19 @@
+import type { FileSystem } from "@deepseek-ai/dsh-fs";
+import type { SessionQueryEngine } from "@deepseek-ai/dsh-session-query";
+import type { WorkspaceChanges } from "@deepseek-ai/dsh-workspace-changes/types";
+import type { SessionId } from "@deepseek-ai/dsh-session/types";
+export const name: string;
+export const inject: readonly string[];
+export const MAX_DOWNLOAD_BYTES: number;
+export interface DownloadContext {
+  connection: { requestRejection(request: Request): 401 | 403 | undefined };
+  sessionQuery: Pick<SessionQueryEngine, "readEvent">;
+  fs: Pick<FileSystem, "resolve" | "lstat" | "contains" | "stat" | "readBytes">;
+  sandboxPolicy: { workspaceRoot: string };
+  get(name: "workspaceChanges"): Pick<WorkspaceChanges, "summary"> | undefined;
+}
+export function downloadResponse(
+  ctx: DownloadContext,
+  request: Request,
+): Promise<Response>;
+export function apply(ctx: unknown): void;

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

@@ -0,0 +1,180 @@
+import { basename } from "node:path";
+import { SessionId, SessionSeq } from "@deepseek-ai/dsh-session/types";
+
+export const name = "windy-downloads";
+export const inject = [
+  "webServer",
+  "connection",
+  "sessionQuery",
+  "fs",
+  "sandboxPolicy",
+];
+export const MAX_DOWNLOAD_BYTES = 20 * 1024 * 1024;
+
+/** Only published event coordinates can select files; browser paths are never accepted. */
+export async function downloadResponse(ctx, request) {
+  if (request.method !== "GET") return failure(405);
+  const denied = ctx.connection.requestRejection(request);
+  if (denied) return failure(denied);
+  const query = new URL(request.url).searchParams;
+  const fields = ["kind", "sessionId", "seq", "index"];
+  if (
+    [...query.keys()].some((key) => !fields.includes(key)) ||
+    fields.some((key) => query.getAll(key).length !== 1)
+  )
+    return failure(400);
+  const kind = query.get("kind"),
+    id = query.get("sessionId"),
+    seq = coordinate(query.get("seq")),
+    index = coordinate(query.get("index"));
+  if (
+    !["present", "changes"].includes(kind) ||
+    !/^[A-Za-z0-9_-]{1,128}$/.test(id ?? "") ||
+    seq === undefined ||
+    index === undefined
+  )
+    return failure(400);
+  try {
+    request.signal.throwIfAborted();
+    const read = await ctx.sessionQuery.readEvent(
+      { sessionId: SessionId(id), seq: SessionSeq(seq), before: 0, after: 0 },
+      request.signal,
+    );
+    if (read.session.id !== id || read.target.seq !== seq) return failure(404);
+    let file,
+      cwd = read.session.cwd ?? ctx.sandboxPolicy.workspaceRoot;
+    if (kind === "present" && read.target.type === "deliverables/presented")
+      file = read.target.data?.files?.[index];
+    if (kind === "changes" && read.target.type === "workspace/changes") {
+      const summary = ctx.get("workspaceChanges")?.summary(SessionId(id), seq);
+      file = summary?.files[index];
+      cwd = summary?.cwd ?? cwd;
+    }
+    if (
+      !file ||
+      typeof file.path !== "string" ||
+      !file.path.trim() ||
+      file.path.length > 4096 ||
+      [...file.path].some((char) => [0, 10, 13].includes(char.charCodeAt(0)))
+    )
+      return failure(404);
+    const fs = ctx.fs;
+    const root = await fs.resolve(ctx.sandboxPolicy.workspaceRoot, {
+      signal: request.signal,
+    });
+    const directory = await fs.resolve(cwd, { signal: request.signal });
+    if (!fs.contains(root, directory)) return failure(404);
+    const inspected = await fs.lstat(file.path, { cwd }, request.signal);
+    if (inspected?.type !== "file") return failure(404);
+    const target = await fs.resolve(file.path, { cwd, signal: request.signal });
+    if (!fs.contains(root, target)) return failure(404);
+    const before = await fs.stat(target, request.signal);
+    if (before?.type !== "file") return failure(404);
+    if (typeof before.size !== "number" || before.size > MAX_DOWNLOAD_BYTES)
+      return failure(413);
+    const bytes = await fs.readBytes(
+      target,
+      request.signal,
+      MAX_DOWNLOAD_BYTES,
+    );
+    if (bytes.byteLength > MAX_DOWNLOAD_BYTES) return failure(413);
+    const current = await fs.resolve(file.path, {
+      cwd,
+      signal: request.signal,
+    });
+    const after = await fs.stat(current, request.signal);
+    if (
+      !fs.contains(root, current) ||
+      !fs.contains(target, current) ||
+      !fs.contains(current, target) ||
+      before.version !== after?.version ||
+      bytes.byteLength !== after?.size
+    )
+      return failure(409);
+    request.signal.throwIfAborted();
+    const filename =
+      [...basename(file.path)]
+        .map((char) =>
+          char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127 ? "_" : char,
+        )
+        .join("")
+        .slice(-180) || "artifact";
+    const extension = filename.split(".").pop()?.toLowerCase();
+    const mime =
+      {
+        docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        pdf: "application/pdf",
+      }[extension] ?? "application/octet-stream";
+    const encoded = encodeURIComponent(filename).replace(
+      /['()*]/g,
+      (value) => `%${value.charCodeAt(0).toString(16).toUpperCase()}`,
+    );
+    return new Response(bytes, {
+      headers: {
+        "content-type": mime,
+        "content-disposition": `attachment; filename="artifact.${/^[a-z0-9]{1,8}$/.test(extension ?? "") ? extension : "bin"}"; filename*=UTF-8''${encoded}`,
+        "cache-control": "no-store",
+        "x-content-type-options": "nosniff",
+        "referrer-policy": "no-referrer",
+      },
+    });
+  } catch (error) {
+    if (error?.code === "FS_TOO_LARGE") return failure(413);
+    return failure(request.signal.aborted ? 499 : 404);
+  }
+}
+function coordinate(value) {
+  return /^(0|[1-9][0-9]*)$/.test(value ?? "") &&
+    Number.isSafeInteger(Number(value))
+    ? Number(value)
+    : undefined;
+}
+function failure(status) {
+  return Response.json(
+    { error: "DOWNLOAD_UNAVAILABLE" },
+    { status, headers: { "cache-control": "no-store" } },
+  );
+}
+
+export function apply(ctx) {
+  const lifetime = new AbortController();
+  ctx.effect(() => () => lifetime.abort());
+  ctx.effect(
+    () =>
+      ctx.webServer.register({
+        kind: "exact",
+        path: "/windy/download",
+        async handler(request, response) {
+          const disconnected = new AbortController();
+          const cancel = () => {
+            if (!response.writableEnded) disconnected.abort();
+          };
+          response.once("close", cancel);
+          try {
+            const headers = new Headers();
+            for (const [key, value] of Object.entries(request.headers))
+              if (typeof value === "string") headers.set(key, value);
+            const input = new Request(
+              new URL(request.url ?? "/", "http://dsh.internal"),
+              {
+                method: request.method,
+                headers,
+                signal: AbortSignal.any([lifetime.signal, disconnected.signal]),
+              },
+            );
+            const result = await downloadResponse(ctx, input);
+            if (response.destroyed) return;
+            response.writeHead(
+              result.status,
+              Object.fromEntries(result.headers),
+            );
+            response.end(Buffer.from(await result.arrayBuffer()));
+          } finally {
+            response.off("close", cancel);
+          }
+        },
+      }),
+    "windy.downloads",
+  );
+}

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

@@ -0,0 +1,20 @@
+{
+  "name": "@southwind-ai/dsh-downloads",
+  "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-deliverables",
+        "@deepseek-ai/dsh-client-ui-renderer"
+      ]
+    }
+  }
+}

package/template/apps/agent-server/plugins/drop-overlay/README.md

@@ -0,0 +1,24 @@
+# 原生工作台材料拖放遮罩
+
+复用系统 `CaseMaterialGlobalDropOverlay.vue` 的视觉契约：90% 背景与 4px 模糊、外边距
+32px、最大 512px 卡片、2px 虚线边框、16px 圆角、40px 内边距，以及 48px 云上传图标、
+18px 半粗标题和 14px 说明。颜色读取 DSH 语义 Token，跟随当前浅色/深色主题。
+上传图标采用项目既有 Lucide cloud-upload 的 ISC 图形路径；减少动态效果时禁用跳动。
+
+当前固定官方 MIT 包 `@deepseek-ai/dsh-client-ui-attachment@0.2.1-rc.2` 只公开整个
+`conversation.input.attachments` 插槽，没有导出的独立 DropOverlay 或装饰插槽。
+原生 React 页面不能直接挂载产品 Vue 组件；本插件只通过公开 `webserver/index-inject`
+追加范围限定的 CSS，不复制附件组件、不替换上传回调，也不新增任何 drag/drop 监听。
+
+兼容边界只匹配 body 的 `role=status` portal、其 `aria-hidden` 插图及 `115×84` SVG viewBox，
+不依赖哈希类名、翻译后的中文或业务内容。alpha.3 的启用插图含 defs/clipPath，阻止插图没有；
+仅前者替换为云上传装饰并跳动，后者保留上游拒绝图案与标题。该 DOM 形状并非官方稳定 API，
+升级前必须运行真实上游附件组件的 enabled/blocked 回归；将来有公开 overlay 插槽时替换此适配。
+
+标题通过已有 locale 插件同一 `conversation/zh-CN` 字典的 `attachment.dropTitle` 设置为
+“松手添加研判材料”。不另外注册同名字典，不覆盖 `dropDesc` 或 `dropBlocked`。
+真实数量/大小限制仍由原生 owner 的 `dropLimits` 传入，不宣称材料已经上传到案件。
+原生 pointer-events:none、拖放准入、拒绝态、目录识别、校验与上传生命周期仍全部由上游负责。
+
+测试执行安装包里的真实 ComposerAttachments、DropOverlay、标签解析和拖放监听，验证接受/拒绝
+分支、实际限制参数、原文件批次回调和状态复位；Hook/portal 使用合成宿主，不代表浏览器视觉验收。