create-windy 0.8.2 → 0.9.1

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

@@ -0,0 +1,342 @@
+import { expect, test } from "bun:test";
+import {
+  mkdir,
+  rm,
+  writeFile,
+  readFile,
+  symlink,
+  link,
+} from "node:fs/promises";
+import { join } from "node:path";
+import { createServer } from "node:http";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import { zipSync, strToU8, unzipSync } from "fflate";
+import { apply, type SkillContext } from "./index.mjs";
+
+import { cleanups, markdown, fixture } from "./test-fixture.js";
+
+test("Host skill lifecycle, attachments, conflict, read-only defaults, export and explicit share", async () => {
+  const f = await fixture();
+  expect(
+    (await (await f.call({ action: "list" })).json()).items[0],
+  ).toMatchObject({ name: "default-skill", readOnly: true });
+  expect((await f.call({ action: "create", raw: markdown() })).status).toBe(
+    200,
+  );
+  const item = await (
+    await f.call({ action: "read", name: "my-skill", source: "personal" })
+  ).json();
+  expect(item.raw).toBe(markdown());
+  expect((await f.call({ action: "create", raw: markdown() })).status).toBe(
+    409,
+  );
+  expect(
+    (await f.call({ action: "create", raw: markdown("default-skill") })).status,
+  ).toBe(409);
+  expect(
+    (
+      await f.call({
+        action: "save",
+        name: "default-skill",
+        source: "defaults",
+        raw: markdown("default-skill"),
+      })
+    ).status,
+  ).toBe(403);
+  expect(
+    (
+      await f.call({
+        action: "save",
+        name: "my-skill",
+        source: "personal",
+        raw: markdown(),
+        version: "stale",
+      })
+    ).status,
+  ).toBe(409);
+  expect(
+    (
+      await f.call({
+        action: "save",
+        name: "my-skill",
+        source: "personal",
+        raw: markdown() + "\n补充步骤",
+        version: item.version,
+      })
+    ).status,
+  ).toBe(200);
+  const bundle = zipSync({
+    "shared/SKILL.md": strToU8(markdown("shared")),
+    "shared/scripts/clean.py": strToU8("print('synthetic')"),
+    "shared/references/template.md": strToU8("模板"),
+    "shared/assets/data.csv": strToU8("value\n1"),
+    "shared/__proto__": strToU8("ordinary attachment"),
+  });
+  expect(
+    (
+      await f.call({
+        action: "import",
+        archive: Buffer.from(bundle).toString("base64"),
+      })
+    ).status,
+  ).toBe(200);
+  const exported = await f.call({
+    action: "export",
+    name: "shared",
+    source: "personal",
+  });
+  expect(exported.headers.get("content-disposition")).toContain("shared.zip");
+  const bytes = new Uint8Array(await exported.arrayBuffer());
+  expect(Object.keys(unzipSync(bytes)).sort()).toEqual([
+    "shared/SKILL.md",
+    "shared/__proto__",
+    "shared/assets/data.csv",
+    "shared/references/template.md",
+    "shared/scripts/clean.py",
+  ]);
+  const recipient = await fixture();
+  expect(
+    (
+      await recipient.call({
+        action: "read",
+        name: "shared",
+        source: "personal",
+      })
+    ).status,
+  ).toBe(404);
+  expect(
+    (
+      await recipient.call({
+        action: "import",
+        archive: Buffer.from(bytes).toString("base64"),
+      })
+    ).status,
+  ).toBe(200);
+  const personal = await (
+    await f.call({ action: "read", name: "my-skill", source: "personal" })
+  ).json();
+  expect(
+    (
+      await f.call({
+        action: "delete",
+        name: "my-skill",
+        source: "personal",
+        version: personal.version,
+      })
+    ).status,
+  ).toBe(400);
+  expect(
+    (
+      await f.call({
+        action: "delete",
+        name: "my-skill",
+        source: "personal",
+        version: personal.version,
+        confirmed: true,
+      })
+    ).status,
+  ).toBe(200);
+  expect(
+    (await f.call({ action: "read", name: "my-skill", source: "personal" }))
+      .status,
+  ).toBe(404);
+});
+test("reject missing auth, foreign workspace, arbitrary path, symlinks and hardlinks", async () => {
+  const f = await fixture();
+  expect(
+    (
+      await f.call(
+        { action: "list" },
+        { cookie: "native=other", origin: "http://localhost" },
+      )
+    ).status,
+  ).toBe(403);
+  expect(
+    (
+      await f.call(
+        { action: "list" },
+        { cookie: "native=owner", origin: "https://foreign.invalid" },
+      )
+    ).status,
+  ).toBe(403);
+  expect(
+    (await f.call({ action: "list", workspaceId: "other-workspace" })).status,
+  ).toBe(403);
+  expect(
+    (await f.call({ action: "list", workspaceId: "missing" })).status,
+  ).toBe(404);
+  expect((await f.call({ action: "list", path: f.other })).status).toBe(400);
+  await mkdir(join(f.root, ".dsh"));
+  await symlink(f.other, join(f.root, ".dsh", "skills"));
+  expect((await f.call({ action: "create", raw: markdown() })).status).toBe(
+    400,
+  );
+  await rm(join(f.root, ".dsh", "skills"));
+  await f.call({ action: "create", raw: markdown() });
+  const skillPath = join(f.root, ".dsh", "skills", "my-skill", "SKILL.md");
+  const original = await readFile(skillPath);
+  await writeFile(join(f.other, "private.md"), markdown());
+  await rm(skillPath);
+  await symlink(join(f.other, "private.md"), skillPath);
+  expect(
+    (await f.call({ action: "read", name: "my-skill", source: "personal" }))
+      .status,
+  ).toBe(400);
+  await rm(skillPath);
+  await writeFile(skillPath, original);
+  await link(skillPath, join(f.other, "linked.md"));
+  expect(
+    (await f.call({ action: "export", name: "my-skill", source: "personal" }))
+      .status,
+  ).toBe(413);
+});
+test("ZIP traversal, duplicate case, symlink, zipbomb, invalid YAML are refused before publication", async () => {
+  const f = await fixture();
+  const archives = [
+    zipSync({ "../SKILL.md": strToU8(markdown()) }),
+    zipSync({
+      "SKILL.md": strToU8(markdown()),
+      "skill.md": strToU8("duplicate"),
+    }),
+    zipSync({
+      "SKILL.md": strToU8(markdown()),
+      ".env": strToU8("PRIVATE_SYNTHETIC"),
+    }),
+    zipSync({
+      "first/SKILL.md": strToU8(markdown()),
+      "second/SKILL.md": strToU8(markdown()),
+    }),
+    zipSync({
+      "SKILL.md": strToU8(markdown()),
+      "scripts/too-big": new Uint8Array(5 * 1024 * 1024),
+    }),
+  ];
+  const symbolic = zipSync({
+    "SKILL.md": strToU8(markdown()),
+    "assets/link": strToU8("target"),
+  });
+  const view = new DataView(symbolic.buffer);
+  let found = 0;
+  for (let offset = 0; offset < symbolic.length - 46; offset++)
+    if (view.getUint32(offset, true) === 0x02014b50 && ++found === 2) {
+      view.setUint32(offset + 38, 0xa1ff0000, true);
+      break;
+    }
+  archives.push(symbolic);
+  for (const archive of archives)
+    expect(
+      (
+        await f.call({
+          action: "import",
+          archive: Buffer.from(archive).toString("base64"),
+        })
+      ).status,
+    ).toBeGreaterThanOrEqual(400);
+  expect(
+    (
+      await f.call({
+        action: "create",
+        raw: "---\nname: Bad_Name\ndescription: bad\n---\ntext",
+      })
+    ).status,
+  ).toBe(400);
+  expect(
+    (
+      await f.call({
+        action: "create",
+        raw: "---\nname: valid\nname: dup\ndescription: bad\n---\ntext",
+      })
+    ).status,
+  ).toBe(400);
+  expect((await (await f.call({ action: "list" })).json()).items).toHaveLength(
+    1,
+  );
+});
+test("actual Node Host route enforces body bound and runs serial mutations", async () => {
+  const f = await fixture();
+  let handler:
+    | Parameters<SkillContext["webServer"]["register"]>[0]["handler"]
+    | undefined;
+  f.ctx.webServer.register = (route) => {
+    handler = route.handler;
+    return () => {};
+  };
+  apply(f.ctx, f.config);
+  const server = createServer((request, response) => {
+    void handler!(request, response);
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  cleanups.push(
+    () => new Promise<void>((resolve) => server.close(() => resolve())),
+  );
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("address");
+  const url = `http://127.0.0.1:${address.port}/windy/skills`,
+    headers = {
+      cookie: "native=owner",
+      origin: "http://localhost",
+      "content-type": "application/json",
+    };
+  const results = await Promise.all(
+    [1, 2].map(() =>
+      fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          action: "create",
+          workspaceId: "owner-workspace",
+          raw: markdown(),
+        }),
+      }),
+    ),
+  );
+  expect(results.map((result) => result.status).sort()).toEqual([200, 409]);
+  expect(
+    (
+      await fetch(url, {
+        method: "POST",
+        headers,
+        body: "x".repeat(6 * 1024 * 1024 + 1),
+      })
+    ).status,
+  ).toBe(413);
+});
+test("client registers native main and sidebar seats using public workspace hook", () => {
+  const source = readFileSync(new URL("./client.js", import.meta.url), "utf8");
+  let plugin: { apply(ctx: unknown): void } | undefined;
+  runInNewContext(source, {
+    window: {
+      __ModuleLoader__: {
+        load({
+          factory,
+        }: {
+          factory(require: (name: string) => unknown): unknown;
+        }) {
+          plugin = factory((name) =>
+            name === "react"
+              ? { createElement() {}, lazy() {} }
+              : { Button() {} },
+          ) as typeof plugin;
+        },
+      },
+    },
+  });
+  const entries: unknown[] = [];
+  plugin!.apply({
+    slots: {
+      inject(_name: string, callback: () => unknown) {
+        callback();
+      },
+      register(options: unknown) {
+        entries.push(options);
+      },
+    },
+  });
+  expect(entries).toContainEqual({ name: "main", key: "windy-skills" });
+  expect(entries).toContainEqual(
+    expect.objectContaining({ name: "sidebar.panellist", id: "windy-skills" }),
+  );
+  expect(source).toContain("useWorkspaces((state) => state.items)");
+  expect(source).not.toContain("iframe");
+});

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

@@ -0,0 +1,293 @@
+import { constants } from "node:fs";
+import {
+  open,
+  mkdir,
+  readdir,
+  lstat,
+  realpath,
+  rename,
+  rm,
+} from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { randomUUID, createHash } from "node:crypto";
+import { LIMITS, fail, skillName, skillDocument } from "./bundle.mjs";
+
+const dirFlags =
+  constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
+export function contained(parent, child) {
+  const diff = relative(parent, child);
+  return (
+    !diff ||
+    (!diff.startsWith("..") && !diff.startsWith("/") && !diff.includes(":"))
+  );
+}
+function anchored(handle, path) {
+  return process.platform === "linux" ? `/proc/self/fd/${handle.fd}` : path;
+}
+async function directory(path) {
+  const handle = await open(path, dirFlags);
+  return { handle, path: anchored(handle, path) };
+}
+async function descend(parent, name, create = false) {
+  const path = join(parent.path, name);
+  if (create)
+    await mkdir(path, { mode: 0o700 }).catch((error) => {
+      if (error.code !== "EEXIST") throw error;
+    });
+  return directory(path);
+}
+export async function skillRoots(ctx, config, workspaceId, run) {
+  if (typeof workspaceId !== "string" || workspaceId.length > 128)
+    fail("请选择工作区。");
+  const workspace = ctx.workspaceRegistry.get(workspaceId);
+  if (!workspace) fail("工作区不可用。", 404);
+  const rootPath = await realpath(ctx.sandboxPolicy.workspaceRoot),
+    cwd = await realpath(workspace.path);
+  if (!contained(rootPath, cwd) || cwd !== resolve(workspace.path))
+    fail("工作区不属于当前用户。", 403);
+  const handles = [];
+  try {
+    let root = await directory(rootPath);
+    handles.push(root.handle);
+    const components = relative(rootPath, cwd).split("/").filter(Boolean);
+    for (const component of components) {
+      root = await descend(root, component);
+      handles.push(root.handle);
+    }
+    const dsh = await descend(root, ".dsh", true);
+    handles.push(dsh.handle);
+    const personal = await descend(dsh, "skills", true);
+    handles.push(personal.handle);
+    const extras = config.extraDefaultSkillDirs ?? [];
+    if (!Array.isArray(extras) || extras.length > 15)
+      fail("默认技能目录配置无效。");
+    const paths = [config.defaultSkillDir, ...extras];
+    if (
+      paths.some(
+        (path) => typeof path !== "string" || !path || path.length > 4096,
+      )
+    )
+      fail("默认技能目录配置无效。");
+    const directories = [];
+    for (const path of new Set(paths.map((path) => resolve(path)))) {
+      const root = await directory(path);
+      directories.push(root);
+      handles.push(root.handle);
+    }
+    const defaults = { directories };
+    return await run({ personal, defaults });
+  } finally {
+    await Promise.all(handles.map((handle) => handle.close()));
+  }
+}
+export async function readFileSafe(parent, name, limit = LIMITS.file) {
+  const handle = await open(
+    join(parent.path, name),
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
+  );
+  try {
+    const before = await handle.stat();
+    if (!before.isFile() || before.nlink !== 1 || before.size > limit)
+      fail("技能文件不是普通文件或体积过大。", 413);
+    const bytes = new Uint8Array(before.size + 1);
+    const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0),
+      after = await handle.stat();
+    if (
+      bytesRead !== before.size ||
+      before.mtimeMs !== after.mtimeMs ||
+      before.ino !== after.ino
+    )
+      fail("文件已变化，请刷新后重试。", 409);
+    return bytes.slice(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+export async function readSkill(root, name, includeFiles = false) {
+  skillName(name);
+  if (root.directories) {
+    const matches = [];
+    for (const candidate of root.directories)
+      if (await exists(candidate, name)) matches.push(candidate);
+    if (!matches.length) fail("默认技能不存在。", 404);
+    if (matches.length !== 1) fail("多个默认技能同名，请检查项目配置。", 409);
+    return readSkill(matches[0], name, includeFiles);
+  }
+  const dir = await descend(root, name);
+  try {
+    const bytes = await readFileSafe(dir, "SKILL.md", LIMITS.markdown),
+      raw = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    const meta = skillDocument(raw);
+    if (meta.name !== name) fail("技能目录和 name 不一致。");
+    const version = createHash("sha256").update(bytes).digest("hex");
+    return {
+      ...meta,
+      raw,
+      version,
+      ...(includeFiles ? { files: await collect(dir) } : {}),
+    };
+  } finally {
+    await dir.handle.close();
+  }
+}
+async function collect(
+  root,
+  prefix = "",
+  state = { files: Object.create(null), total: 0, count: 0 },
+) {
+  for (const entry of await readdir(root.path, { withFileTypes: true })) {
+    const name = entry.name,
+      key = prefix + name;
+    if (name.startsWith(".") || ++state.count > LIMITS.entries)
+      fail("技能包含隐藏文件或过多文件。", 413);
+    if (entry.isDirectory()) {
+      const child = await descend(root, name);
+      try {
+        await collect(child, `${key}/`, state);
+      } finally {
+        await child.handle.close();
+      }
+    } else {
+      if (!entry.isFile()) fail("技能不能包含符号链接或特殊文件。");
+      const bytes = await readFileSafe(root, name);
+      if ((state.total += bytes.length) > LIMITS.total)
+        fail("技能展开体积过大。", 413);
+      state.files[key] = bytes;
+    }
+  }
+  return state.files;
+}
+export async function listSkills(roots) {
+  const result = [];
+  for (const [source, root] of Object.entries(roots)) {
+    const directories = root.directories ?? [root];
+    const entries = [];
+    for (const directory of directories)
+      entries.push(
+        ...(await readdir(directory.path, { withFileTypes: true })).slice(
+          0,
+          128,
+        ),
+      );
+    const seen = new Set();
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !/^[a-z0-9-]{1,64}$/.test(entry.name))
+        continue;
+      if (seen.has(entry.name)) continue;
+      seen.add(entry.name);
+      try {
+        const item = await readSkill(root, entry.name);
+        result.push({
+          name: item.name,
+          description: item.description,
+          displayName: item.displayName ?? item.name,
+          source,
+          readOnly: source === "defaults",
+          userInvocable: item.userInvocable,
+        });
+      } catch {
+        /* A broken skill cannot expose another path or stop the catalog. */
+      }
+    }
+  }
+  return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function installSkill(roots, bundle) {
+  if (
+    (await exists(roots.defaults, bundle.name)) ||
+    (await exists(roots.personal, bundle.name))
+  )
+    fail("同名技能已存在，请修改 name 后导入。", 409);
+  const finalPath = join(roots.personal.path, bundle.name);
+  try {
+    await mkdir(finalPath, { mode: 0o700 });
+  } catch (error) {
+    if (error.code === "EEXIST") fail("同名技能已存在。", 409);
+    throw error;
+  }
+  let completed = false;
+  try {
+    // SKILL.md is published last, so the native provider never observes a partial bundle.
+    const entries = Object.entries(bundle.files).sort(
+      ([a], [b]) => (a === "SKILL.md") - (b === "SKILL.md"),
+    );
+    for (const [name, bytes] of entries) {
+      const parts = name.split("/"),
+        handles = [];
+      let target = await directory(finalPath);
+      handles.push(target.handle);
+      try {
+        for (const part of parts.slice(0, -1)) {
+          target = await descend(target, part, true);
+          handles.push(target.handle);
+        }
+        const file = await open(
+          join(target.path, parts.at(-1)),
+          constants.O_WRONLY |
+            constants.O_CREAT |
+            constants.O_EXCL |
+            constants.O_NOFOLLOW,
+          0o600,
+        );
+        try {
+          await file.writeFile(bytes);
+        } finally {
+          await file.close();
+        }
+      } finally {
+        await Promise.all(handles.map((handle) => handle.close()));
+      }
+    }
+    completed = true;
+  } finally {
+    if (!completed) await rm(finalPath, { recursive: true, force: true });
+  }
+}
+
+export async function updateSkill(root, name, raw, version) {
+  const current = await readSkill(root, name);
+  if (current.version !== version || skillDocument(raw).name !== name)
+    fail("技能已变化或 name 不一致，请刷新后另存。", 409);
+  const dir = await descend(root, name),
+    temp = `.edit-${randomUUID()}`;
+  try {
+    const file = await open(
+      join(dir.path, temp),
+      constants.O_WRONLY |
+        constants.O_CREAT |
+        constants.O_EXCL |
+        constants.O_NOFOLLOW,
+      0o600,
+    );
+    try {
+      await file.writeFile(raw, "utf8");
+    } finally {
+      await file.close();
+    }
+    if ((await readSkill(root, name)).version !== version)
+      fail("技能已变化，请刷新。", 409);
+    await rename(join(dir.path, temp), join(dir.path, "SKILL.md"));
+  } finally {
+    await rm(join(dir.path, temp), { force: true });
+    await dir.handle.close();
+  }
+}
+export async function deleteSkill(root, name, version) {
+  const current = await readSkill(root, name);
+  if (current.version !== version) fail("技能已变化，请刷新。", 409);
+  await rm(join(root.path, name), { recursive: true });
+}
+async function exists(root, name) {
+  if (root.directories) {
+    for (const directory of root.directories)
+      if (await exists(directory, name)) return true;
+    return false;
+  }
+  return lstat(join(root.path, name)).then(
+    () => true,
+    (error) => {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    },
+  );
+}