Skip to content

Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演

18.1 KB
Raw Blame
import test from "node:test";
import assert from "node:assert/strict";
import { createHash } from "node:crypto";

import {
  applyCuratedOrigin,
  curatedSourceKey,
  curatedPackTitle,
  normalizeCuratedCatalog,
  normalizeCuratedMetrics,
  normalizeCuratedPreview,
  prepareCuratedEntriesPackage,
  prepareCuratedEntryPackage,
  prepareCuratedPackageVersion,
  validateCuratedPackageContents,
  validateCuratedPackageIndex,
  verifyCuratedPackageBlob
} from "../extension/curated-catalog.js";

test("a curated archive above 128 MiB still requires its catalog size and SHA-256", async () => {
  const chunk = new Uint8Array(1024 * 1024);
  const parts = Array(128).fill(chunk);
  parts.push(new Uint8Array([1]));
  const archive = new Blob(parts);
  const hash = createHash("sha256");
  for (const part of parts) hash.update(part);
  const digest = hash.digest("hex");

  assert.equal(await verifyCuratedPackageBlob(archive, digest, archive.size), true);
  await assert.rejects(verifyCuratedPackageBlob(archive, digest, archive.size - 1), /大小与目录不一致/);
  await assert.rejects(verifyCuratedPackageBlob(new Blob([new Uint8Array(22)]), digest, 22), /校验失败/);
});

function catalogItem(overrides = {}) {
  return {
    id: "feature:cinematic",
    title: "电影感构图精选",
    type: "image_prompt",
    packageId: "cinematic-foundations",
    packageVersion: "1.0.0",
    authorId: "promptdirector-editorial",
    author: "PromptDirector Editorial",
    license: "CC BY 4.0",
    rightsStatus: "verified_authorized",
    rightsReviewUrl: "https://wchao6891.github.io/PromptDirector-Curated/reviews/cinematic-foundations.json",
    updatedAt: "2026-07-29T00:00:00.000Z",
    coverUrl: "https://wchao6891.github.io/PromptDirector-Curated/covers/cinematic.webp",
    previewUrl: "https://wchao6891.github.io/PromptDirector-Curated/previews/cinematic-foundations/preview.json",
    downloadUrl: "https://github.com/wchao6891/PromptDirector-Curated/releases/download/cinematic-1.0.0/cinematic.zip",
    sha256: "a".repeat(64),
    archiveBytes: 1024,
    caseCount: 2,
    imageCount: 2,
    videoCount: 0,
    order: 1,
    ...overrides
  };
}

test("curated catalogs expose ordered themes with trusted package assets", () => {
  const catalog = normalizeCuratedCatalog({
    format: "prompt-director-curated",
    version: 2,
    updatedAt: "2026-07-29T00:00:00.000Z",
    themes: [catalogItem({ id: "feature:second", order: 2, packageId: "second-package" }), catalogItem()]
  });
  assert.deepEqual(catalog.themes.map((theme) => theme.order), [1, 2]);
  assert.equal(catalog.themes[0].packageId, "cinematic-foundations");
  assert.throws(() => normalizeCuratedCatalog({
    format: "prompt-director-curated",
    version: 2,
    themes: [catalogItem({ coverUrl: "https://attacker.example/cover.webp" })]
  }), /不受信任/);
  assert.throws(() => normalizeCuratedCatalog({
    format: "prompt-director-curated",
    version: 2,
    themes: [catalogItem({ sha256: "not-a-checksum" })]
  }), /校验值/);
  assert.throws(() => normalizeCuratedCatalog({
    format: "prompt-director-curated",
    version: 2,
    themes: [catalogItem({ rightsStatus: "unverified" })]
  }), /缺少必填字段/);
  assert.throws(() => normalizeCuratedCatalog({
    format: "prompt-director-curated",
    version: 1,
    items: [catalogItem()]
  }), /目录版本过旧/);
});

test("curated previews expose inert prompt text and trusted poster images for the exact package version", () => {
  const preview = normalizeCuratedPreview({
    format: "prompt-director-curated-preview",
    version: 1,
    catalogId: "feature:cinematic",
    packageId: "cinematic-foundations",
    packageVersion: "1.0.0",
    entries: [
      {
        id: "one",
        title: "案例一",
        text: "只作为文字复制",
        author: "@creator",
        rights: "权利归原作者",
        sourceUrl: "https://source.example/one",
        mediaKind: "image",
        previewImageUrl: "https://wchao6891.github.io/PromptDirector-Curated/previews/cinematic-foundations/media/one.webp",
        width: 1200,
        height: 900
      },
      {
        id: "two",
        title: "案例二",
        text: "视频提示词",
        author: "@creator",
        rights: "权利归原作者",
        sourceUrl: "",
        mediaKind: "video",
        previewImageUrl: "https://wchao6891.github.io/PromptDirector-Curated/previews/cinematic-foundations/media/two.webp",
        videoUrl: "https://github.com/wchao6891/PromptDirector-Curated/releases/download/cinematic-media-1.0.0/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.mp4",
        videoSha256: "b".repeat(64),
        videoBytes: 2048,
        videoMimeType: "video/mp4",
        width: 1200,
        height: 900
      }
    ]
  }, catalogItem());
  assert.equal(preview.entries[0].text, "只作为文字复制");
  assert.equal(preview.entries[1].videoMimeType, "video/mp4");
  assert.deepEqual(normalizeCuratedPreview(preview, catalogItem()), preview);
  assert.throws(() => normalizeCuratedPreview({ ...preview, packageVersion: "2.0.0" }, catalogItem()), /版本不一致/);
  assert.throws(() => normalizeCuratedPreview({
    ...preview,
    entries: preview.entries.map((entry, index) => index ? entry : { ...entry, previewImageUrl: "https://attacker.example/one.webp" })
  }, catalogItem()), /不受信任/);
});

test("curated download sorting accepts only a complete real metric snapshot", () => {
  const catalog = {
    format: "prompt-director-curated",
    version: 2,
    updatedAt: "2026-07-29T00:00:00.000Z",
    themes: [catalogItem()]
  };
  assert.deepEqual(normalizeCuratedMetrics({
    format: "prompt-director-curated-metrics",
    version: 1,
    updatedAt: "2026-07-29T00:00:00.000Z",
    downloads: { "feature:cinematic": 14 }
  }, catalog).downloads, { "feature:cinematic": 14 });
  assert.throws(() => normalizeCuratedMetrics({
    format: "prompt-director-curated-metrics",
    version: 1,
    updatedAt: "2026-07-29T00:00:00.000Z",
    downloads: {}
  }, catalog), /不完整/);
});

test("installing a curated package records provenance without retaining service or private metadata", () => {
  const item = catalogItem();
  const entry = applyCuratedOrigin({
    id: "case:one",
    title: "Case",
    url: "https://source.example",
    creationMeta: { sourceEntryIds: ["private"] }
  }, item, "2026-07-29T01:00:00.000Z");
  assert.deepEqual(entry.curatedOrigin, {
    catalogId: item.id,
    packageId: item.packageId,
    packageVersion: item.packageVersion,
    author: item.author,
    license: item.license,
    rightsStatus: item.rightsStatus,
    rightsReviewUrl: item.rightsReviewUrl,
    sourceEntryId: "case:one",
    installedAt: "2026-07-29T01:00:00.000Z"
  });
  assert.equal(JSON.stringify(entry.curatedOrigin).includes("private"), false);
});

test("each curated package version uses deterministic local ids so updates never overwrite edited copies", () => {
  const item = catalogItem();
  const library = {
    entries: [{
      id: "original",
      visuals: [{ id: "visual-one", screenshotPath: "images/one.webp" }],
      primaryVisualId: "visual-one"
    }],
    organizerState: {
      collections: [{ id: "collection:one", name: "精选", order: 0, entryIds: ["original"] }]
    }
  };
  const first = prepareCuratedPackageVersion(library, item);
  const repeated = prepareCuratedPackageVersion(library, item);
  const updated = prepareCuratedPackageVersion(library, catalogItem({ packageVersion: "1.1.0" }));

  assert.equal(first.entries[0].id, repeated.entries[0].id);
  assert.notEqual(first.entries[0].id, updated.entries[0].id);
  assert.equal(curatedSourceKey(first.entries[0]), curatedSourceKey(updated.entries[0]));
  assert.equal(first.organizerState.collections[0].entryIds[0], first.entries[0].id);
  assert.equal(first.entries[0].primaryVisualId, first.entries[0].visuals[0].id);
});

test("curated package namespacing remaps project parents together with project ids", () => {
  const prepared = prepareCuratedPackageVersion({
    entries: [{ id: "original", mediaAssets: [] }],
    organizerState: {
      collections: [
        { id: "root", name: "根项目", parentId: null, order: 0, entryIds: [] },
        { id: "child", name: "子项目", parentId: "root", order: 0, entryIds: ["original"] }
      ]
    }
  }, catalogItem());
  const [root, child] = prepared.organizerState.collections;

  assert.equal(root.parentId, null);
  assert.equal(child.parentId, root.id);
  assert.equal(child.entryIds[0], prepared.entries[0].id);
});

test("legacy version-scoped curated ids resolve to the same stable source identity", () => {
  const legacy = {
    id: "curated:cinematic-foundations:1.0.0:entry:original",
    curatedOrigin: { packageId: "cinematic-foundations", packageVersion: "1.0.0" }
  };
  const current = prepareCuratedPackageVersion({ entries: [{ id: "original", mediaAssets: [] }] }, catalogItem({ packageVersion: "1.1.0" })).entries[0];

  assert.equal(curatedSourceKey(legacy), curatedSourceKey(current));
});

test("current media assets receive package-scoped ids together with their relationships", () => {
  const prepared = prepareCuratedPackageVersion({
    entries: [{
      id: "current-entry",
      mediaAssets: [
        { id: "image-one", kind: "image", assetPath: "images/one.webp" },
        { id: "image-two", kind: "image", assetPath: "images/two.webp", derivedFromAssetId: "image-one" }
      ],
      primaryMediaId: "image-two",
      timeNotes: [{ id: "note-one", assetId: "image-two", frameAssetId: "image-one" }],
      facetAssignments: [{ facetId: "facet:one", nodeId: "node:one", visualId: "image-two" }]
    }]
  }, catalogItem());
  const entry = prepared.entries[0];

  assert.match(entry.mediaAssets[0].id, /^curated:cinematic-foundations:1\.0\.0:visual:/);
  assert.equal(entry.primaryMediaId, entry.mediaAssets[1].id);
  assert.equal(entry.mediaAssets[1].derivedFromAssetId, entry.mediaAssets[0].id);
  assert.equal(entry.timeNotes[0].assetId, entry.mediaAssets[1].id);
  assert.equal(entry.timeNotes[0].frameAssetId, entry.mediaAssets[0].id);
  assert.equal(entry.facetAssignments[0].visualId, entry.mediaAssets[1].id);
  assert.equal("visuals" in entry, false);
});

test("saving from the curated gallery produces exactly one reviewed local case", () => {
  const item = catalogItem();
  const prepared = prepareCuratedPackageVersion({
    entries: [
      { id: "one", title: "案例一", mediaAssets: [], primaryMediaId: "" },
      { id: "two", title: "案例二", mediaAssets: [], primaryMediaId: "" }
    ]
  }, item);
  const targetId = prepared.entries[1].id;
  const selected = prepareCuratedEntryPackage(prepared, targetId);

  assert.deepEqual(selected.entries.map((entry) => entry.title), ["案例二"]);
  assert.equal(selected.entries[0].curatedOrigin.packageId, item.packageId);
  assert.deepEqual(selected.organizerState.collections, []);
  assert.throws(() => prepareCuratedEntryPackage(prepared, "missing"), /请先选择|无法作为单个/);
});

test("theme saves select a deterministic batch while preserving its collection", () => {
  const prepared = prepareCuratedPackageVersion({
    entries: [
      { id: "one", title: "案例一", mediaAssets: [], primaryMediaId: "" },
      { id: "two", title: "案例二", mediaAssets: [], primaryMediaId: "" },
      { id: "three", title: "案例三", mediaAssets: [], primaryMediaId: "" }
    ],
    organizerState: {
      collections: [{ id: "theme", name: "主题", order: 0, entryIds: ["one", "two", "three"] }]
    }
  }, catalogItem());
  const selected = prepareCuratedEntriesPackage(prepared, prepared.entries.slice(0, 2).map((entry) => entry.id));

  assert.deepEqual(selected.entries.map((entry) => entry.title), ["案例一", "案例二"]);
  assert.deepEqual(selected.organizerState.collections[0].entryIds, selected.entries.map((entry) => entry.id));
});

test("theme saves retain empty project ancestors needed by selected child cases", () => {
  const prepared = prepareCuratedPackageVersion({
    entries: [
      { id: "one", title: "案例一", mediaAssets: [], primaryMediaId: "" },
      { id: "two", title: "案例二", mediaAssets: [], primaryMediaId: "" }
    ],
    organizerState: {
      collections: [
        { id: "root", name: "主题", parentId: null, order: 0, entryIds: [] },
        { id: "child", name: "子主题", parentId: "root", order: 0, entryIds: ["one", "two"] }
      ]
    }
  }, catalogItem());
  const selected = prepareCuratedEntriesPackage(prepared, [prepared.entries[0].id]);
  const [root, child] = selected.organizerState.collections;

  assert.equal(root.entryIds.length, 0);
  assert.equal(child.parentId, root.id);
  assert.deepEqual(child.entryIds, [selected.entries[0].id]);
});

test("a curated package must match the reviewed catalog counts", () => {
  const item = catalogItem({ imageCount: 1 });
  assert.doesNotThrow(() => validateCuratedPackageContents(item, {
    entries: [{ id: "one" }, { id: "two" }],
    images: new Map([["one", new Blob(["image"])]]),
  }));
  assert.throws(() => validateCuratedPackageContents(item, {
    entries: [{ id: "one" }],
    images: new Map([["one", new Blob(["image"])]]),
  }), /案例数量与目录不一致/);
});

test("a curated mixed-media package must match its reviewed video count", () => {
  const item = catalogItem({ imageCount: 2, videoCount: 1 });
  const parsed = {
    entries: [{ id: "image" }, { id: "video" }],
    images: new Map([
      ["image", new Blob(["image"], { type: "image/webp" })],
      ["poster", new Blob(["poster"], { type: "image/webp" })]
    ]),
    assets: new Map([
      ["image", new Blob(["image"], { type: "image/webp" })],
      ["poster", new Blob(["poster"], { type: "image/webp" })],
      ["video", new Blob(["video"], { type: "video/mp4" })]
    ])
  };

  assert.doesNotThrow(() => validateCuratedPackageContents(item, parsed));
  assert.throws(() => validateCuratedPackageContents(item, {
    ...parsed,
    assets: new Map([...parsed.assets].filter(([id]) => id !== "video"))
  }), /视频数量与目录不一致/);
});

test("a curated package index validates every reviewed media path before extracting one case", () => {
  const item = catalogItem({ imageCount: 2, videoCount: 1 });
  const library = {
    entries: [
      {
        id: "one",
        mediaAssets: [
          { id: "image-one", kind: "image", assetPath: "images/one.webp" },
          { id: "video-one", kind: "video", assetPath: "videos/one.mp4" }
        ]
      },
      {
        id: "two",
        mediaAssets: [{ id: "image-two", kind: "image", assetPath: "images/two.webp" }]
      }
    ]
  };
  const names = ["library.json", "images/one.webp", "videos/one.mp4", "images/two.webp"];

  assert.doesNotThrow(() => validateCuratedPackageIndex(item, library, names));
  assert.throws(() => validateCuratedPackageIndex(item, library, names.filter((name) => name !== "videos/one.mp4")), /ZIP 不一致/);
  assert.throws(() => validateCuratedPackageIndex(item, {
    ...library,
    entries: [library.entries[0], {
      ...library.entries[1],
      mediaAssets: [{ id: "image-one", kind: "image", assetPath: "images/two.webp" }]
    }]
  }, names), /无效或重复/);
  assert.throws(() => validateCuratedPackageIndex(catalogItem({ imageCount: 1, videoCount: 1 }), library, names), /图片数量与目录不一致/);
});


test("source selections can be browsed and saved without inventing authorization", () => {
  const item = catalogItem({ rightsStatus: "source_unverified", license: "权利归原作者 · 授权未核验" });
  const catalog = normalizeCuratedCatalog({
    format: "prompt-director-curated", version: 2,
    updatedAt: item.updatedAt, themes: [item]
  });
  assert.equal(catalog.themes[0].rightsStatus, "source_unverified");
  const saved = applyCuratedOrigin({ id: "source-case", title: "来源案例" }, catalog.themes[0]);
  assert.equal(saved.curatedOrigin.rightsStatus, "source_unverified");
  assert.equal(saved.curatedOrigin.license, item.license);
  assert.equal(saved.curatedOrigin.rightsReviewUrl, item.rightsReviewUrl);
});


test('one unknown case author does not hide the entire published preview or invent attribution', () => {
  const item = catalogItem();
  const entry = { id: 'known', title: '案例', text: '原始提示词', author: '原作者', rights: '权利归原作者 · 授权未核验', mediaKind: 'image', sourceUrl: 'https://example.com/source', previewImageUrl: item.coverUrl, width: 100, height: 100 };
  const value = { format: 'prompt-director-curated-preview', version: 1, catalogId: item.id, packageId: item.packageId, packageVersion: item.packageVersion, entries: [entry, { ...entry, id: 'unknown', author: '' }] };
  const preview = normalizeCuratedPreview(value, item);
  assert.equal(preview.entries.length, 2);
  assert.equal(preview.entries[0].author, '原作者');
  assert.equal(preview.entries[1].author, '');
  assert.equal(preview.entries[1].rights, entry.rights);
  for (const field of ['id', 'title', 'text', 'rights', 'mediaKind']) {
    assert.throws(() => normalizeCuratedPreview({ ...value, entries: [entry, { ...value.entries[1], [field]: '' }] }, item), /必填字段/);
  }
  assert.throws(() => normalizeCuratedPreview({ ...value, entries: [entry, { ...value.entries[1], previewImageUrl: 'https://untrusted.example/a.png' }] }, item), /不受信任/);
});


test("English pack display names never rename imported cases or change the download identity", (t) => {
  const original = catalogItem({ title: "精选原名" });
  t.mock.timers.enable({ apis: ["Date"], now: Date.parse(original.updatedAt) });
  const catalog = normalizeCuratedCatalog({
    format: "prompt-director-curated", version: 2,
    updatedAt: original.updatedAt,
    themes: [{ ...original, titleEn: "  Curated picks  " }]
  });
  const translated = catalog.themes[0];
  assert.equal(curatedPackTitle(translated, "en"), "Curated picks");
  assert.equal(curatedPackTitle(translated, "zh-CN"), original.title);
  assert.equal(curatedPackTitle(original, "en"), original.title);
  for (const field of ["id", "title", "packageId", "packageVersion", "downloadUrl", "sha256", "archiveBytes"])
    assert.equal(translated[field], original[field]);
  const library = { entries: [{ id: "source-case", title: "案例原名", text: "原始提示词", mediaAssets: [] }] };
  assert.deepEqual(prepareCuratedPackageVersion(library, translated), prepareCuratedPackageVersion(library, original));
});