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. 提示词导演

16.6 KB
Raw Blame
import test from "node:test";
import assert from "node:assert/strict";

import { createDefaultFacetCatalog } from "../extension/facets.js";
import { mergeLibraryPackage, parseCompleteFolderBackup, parseLibraryPackage } from "../extension/library-package.js";
import { SCHEMA_VERSION, createDefaultTaxonomy } from "../extension/taxonomy.js";
import { restoreTrashItems } from "../extension/trash.js";
import { createComposerSession } from "../extension/composer.js";

test("salvage mode drops one missing media file without blocking recoverable cases", () => {
  const source = packageValue([
    entry("case:missing", {
      text: "这个案例仍有可恢复的正文",
      mediaAssets: [image("image:missing")],
      primaryMediaId: "image:missing"
    }),
    entry("case:good", {
      mediaAssets: [image("image:good")],
      primaryMediaId: "image:good"
    })
  ]);
  const files = new Map([[
    "images/image-good.webp",
    new Blob(["good!"], { type: "image/webp" })
  ]]);

  const parsed = parseLibraryPackage(source, files, { salvageInvalidMedia: true });

  assert.deepEqual(parsed.entries.map((item) => item.id), ["case:missing", "case:good"]);
  assert.deepEqual(parsed.entries[0].mediaAssets, []);
  assert.equal(parsed.entries[0].primaryMediaId, "");
  assert.deepEqual(parsed.entries[1].mediaAssets.map((asset) => asset.id), ["image:good"]);
  assert.deepEqual([...parsed.assets.keys()], ["image:good"]);
  assert.equal(parsed.importStats.droppedMediaFiles, 1);
  assert.deepEqual(parsed.importDiagnostics.filter(({ code }) => code === "media_file_dropped"), [{
    code: "media_file_dropped",
    severity: "media",
    action: "dropped",
    entryId: "case:missing",
    assetId: "image:missing",
    path: "images/image-missing.webp",
    reason: "missing_file"
  }]);
});

test("salvage mode reports a media MIME mismatch without hiding the case text", () => {
  const source = packageValue([entry("case:type-mismatch", {
    mediaAssets: [image("image:type-mismatch")],
    primaryMediaId: "image:type-mismatch"
  })]);
  const files = new Map([[
    "images/image-type-mismatch.webp",
    new Blob(["wrong"], { type: "text/plain" })
  ]]);

  const parsed = parseLibraryPackage(source, files, { salvageInvalidMedia: true });

  assert.equal(parsed.entries.length, 1);
  assert.deepEqual(parsed.entries[0].mediaAssets, []);
  assert.equal(parsed.importDiagnostics.at(-1).reason, "type_mismatch");
  assert.equal(parsed.importStats.droppedMediaFiles, 1);
});

test("salvage mode treats one unsafe media descriptor as a case-local failure", () => {
  const broken = image("image:unsafe-path");
  broken.assetPath = "../images/unsafe.webp";
  const source = packageValue([entry("case:unsafe-path", {
    mediaAssets: [broken],
    primaryMediaId: broken.id
  })]);

  const parsed = parseLibraryPackage(source, new Map(), { salvageInvalidMedia: true });

  assert.equal(parsed.entries.length, 1);
  assert.deepEqual(parsed.entries[0].mediaAssets, []);
  assert.equal(parsed.importStats.droppedMediaDescriptors, 1);
  assert.equal(parsed.importDiagnostics.at(-1).code, "media_descriptor_dropped");
});

test("the import preview keeps salvage diagnostics produced before media blobs are removed from the message", () => {
  const source = packageValue([entry("case:preview", {
    mediaAssets: [image("image:preview-missing")],
    primaryMediaId: "image:preview-missing"
  })]);
  const parsed = parseLibraryPackage(source, new Map(), { salvageInvalidMedia: true });
  const importLibrary = { ...parsed };
  delete importLibrary.assets;
  delete importLibrary.images;
  delete importLibrary.skillAssets;

  const preview = mergeLibraryPackage({ entries: [] }, importLibrary, {
    preserveLibraryConfiguration: true
  });

  assert.equal(preview.importStats.droppedMediaFiles, 1);
  assert.equal(preview.importDiagnostics.filter(({ code }) => code === "media_file_dropped").length, 1);
});

test("salvage mode skips a media-only case when its last recoverable file is broken", () => {
  const source = packageValue([
    entry("case:good"),
    entry("case:media-only", {
      title: "",
      text: "",
      note: "",
      url: "",
      mediaAssets: [image("image:broken-only")],
      primaryMediaId: "image:broken-only"
    })
  ]);
  source.organizerState = {
    collections: [{
      id: "collection:test",
      name: "项目",
      order: 0,
      entryIds: ["case:good", "case:media-only"]
    }]
  };

  const parsed = parseLibraryPackage(source, new Map(), { salvageInvalidMedia: true });

  assert.deepEqual(parsed.entries.map((item) => item.id), ["case:good"]);
  assert.deepEqual(parsed.organizerState.collections[0].entryIds, ["case:good"]);
  assert.equal(parsed.importStats.inputCases, 2);
  assert.equal(parsed.importStats.keptCases, 1);
  assert.equal(parsed.importStats.skippedCases, 1);
  assert.equal(parsed.importStats.droppedMediaFiles, 1);
  assert.deepEqual(parsed.importDiagnostics.at(-1), {
    code: "case_skipped_after_media_loss",
    severity: "case",
    action: "skipped",
    entryId: "case:media-only",
    reason: "no_usable_content"
  });
});

test("rescue mode isolates broken private resources without leaving placeholders", () => {
  const source = packageValue([entry("case:healthy")]);
  source.trashState = {
    version: 1,
    items: [{
      id: "trash:entry:case:trashed",
      kind: "entry",
      targetId: "case:trashed",
      deletedAt: "2026-08-27T00:00:00.000Z",
      snapshot: entry("case:trashed", {
        text: "仍可恢复的回收站正文",
        mediaAssets: [image("image:trash-missing")],
        primaryMediaId: "image:trash-missing"
      }),
      relationships: { collections: [] }
    }]
  };
  source.composerSessions = [createComposerSession({
    id: "session:rescue",
    referenceSnapshots: [{
      entryId: "temp-reference:rescue",
      alias: "@参考1",
      title: "缺失临时图片",
      sourceType: "temporary",
      referenceKind: "reference",
      referenceText: "仍保留的文字参考",
      imageRefs: [{ visualId: "temp-asset:missing", mimeType: "image/webp" }],
      assetRefs: [{
        assetId: "temp-asset:missing",
        kind: "image",
        mimeType: "image/webp",
        name: "missing.webp",
        byteSize: 5,
        archivePath: "temp-references/session-rescue/missing.webp"
      }]
    }]
  })];
  source.creativeRuns = [{
    id: "run:rescue",
    sessionId: "session:rescue",
    promptVersionId: "prompt:rescue",
    promptText: "仍保留的历史提示词",
    createdAt: "2026-08-27T00:00:00.000Z",
    updatedAt: "2026-08-27T00:00:00.000Z",
    outputs: [{
      visual: {
        id: "creative:missing",
        kind: "image",
        mimeType: "image/webp",
        byteSize: 5,
        capturedAt: "2026-08-27T00:00:00.000Z",
        assetPath: "creative-results/run-rescue/missing.webp"
      },
      capturedAt: "2026-08-27T00:00:00.000Z",
      signals: [{ type: "captured", at: "2026-08-27T00:00:00.000Z" }]
    }]
  }];
  source.creativeSkills = {
    version: 1,
    items: [{
      id: "skill:rescue",
      callName: "救援方法",
      portableId: "rescue-method",
      description: "方法正文仍可恢复",
      currentVersionId: "skill-version:rescue",
      versions: [{
        id: "skill-version:rescue",
        createdAt: "2026-08-27T00:00:00.000Z",
        reason: "imported",
        source: "imported",
        skillMarkdown: "# 救援方法",
        references: [],
        provenanceMarkdown: ""
      }],
      packageFiles: [{
        path: "SKILL.md",
        assetId: "skill-file:missing",
        byteSize: 5,
        mimeType: "text/markdown",
        archivePath: "skills/rescue-method/skill-file-missing/SKILL.md"
      }],
      textModeConfirmed: false,
      runtimeDependencies: [],
      createdAt: "2026-08-27T00:00:00.000Z",
      updatedAt: "2026-08-27T00:00:00.000Z"
    }]
  };

  const parsed = parseLibraryPackage(source, new Map(), { salvageInvalidMedia: true });

  assert.deepEqual(parsed.trashState.items[0].snapshot.mediaAssets, []);
  assert.equal(parsed.trashState.items[0].snapshot.text, "仍可恢复的回收站正文");
  assert.deepEqual(parsed.composerSessions[0].referenceSnapshots[0].assetRefs, []);
  assert.deepEqual(parsed.composerSessions[0].referenceSnapshots[0].imageRefs, []);
  assert.equal(parsed.composerSessions[0].referenceSnapshots[0].referenceText, "仍保留的文字参考");
  assert.deepEqual(parsed.creativeRuns[0].outputs, []);
  assert.equal(parsed.creativeRuns[0].promptText, "仍保留的历史提示词");
  assert.deepEqual(parsed.creativeSkills.items[0].packageFiles, []);
  assert.match(JSON.stringify(parsed.importDiagnostics), /trash_media_dropped/);
  assert.match(JSON.stringify(parsed.importDiagnostics), /temporary_asset_dropped/);
  assert.match(JSON.stringify(parsed.importDiagnostics), /creative_output_dropped/);
  assert.match(JSON.stringify(parsed.importDiagnostics), /skill_file_dropped/);
});

test("complete folder backup parsing stays strict even if a caller requests ZIP media salvage", async () => {
  const source = packageValue([entry("case:strict", {
    mediaAssets: [image("image:strict-missing")],
    primaryMediaId: "image:strict-missing"
  })]);

  await assert.rejects(
    () => parseCompleteFolderBackup(source, new Map(), { salvageInvalidMedia: true }),
    /截图缺失/
  );
});

test("salvage mode removes relationships and AI labels that pointed at a dropped media file", () => {
  const source = packageValue([entry("case:relations", {
    mediaAssets: [image("image:missing-related"), image("image:kept")],
    primaryMediaId: "image:missing-related",
    mediaPrompts: [{
      assetId: "image:missing-related",
      text: "只属于坏文件的提示词",
      source: "manual",
      updatedAt: "2026-08-26T00:00:00.000Z"
    }],
    facetAssignments: [{
      facetId: "subject",
      nodeId: "subject.character",
      visualId: "image:missing-related",
      status: "confirmed",
      source: "vision_model"
    }]
  })]);
  const files = new Map([[
    "images/image-kept.webp",
    new Blob(["good!"], { type: "image/webp" })
  ]]);

  const parsed = parseLibraryPackage(source, files, { salvageInvalidMedia: true });
  const recovered = parsed.entries[0];

  assert.equal(recovered.primaryMediaId, "image:kept");
  assert.deepEqual(recovered.mediaPrompts, []);
  assert.deepEqual(recovered.facetAssignments, []);
  assert.equal(parsed.importStats.droppedAiAssignments, 1);
  assert.equal(parsed.importDiagnostics.filter(({ code }) => code === "ai_assignment_dropped").length, 1);
});

test("complete backup import drops broken AI labels before a trashed case is restored", async () => {
  const source = packageValue([]);
  const trashed = entry("case:trashed", {
    mediaAssets: [image("image:trashed")],
    primaryMediaId: "image:trashed",
    facetAssignments: [{
      facetId: "missing-facet",
      nodeId: "missing-node",
      visualId: "image:trashed",
      status: "confirmed",
      source: "vision_model"
    }]
  });
  source.trashState = {
    version: 1,
    items: [{
      id: "trash:entry:case:trashed",
      kind: "entry",
      targetId: "case:trashed",
      deletedAt: "2026-08-26T01:00:00.000Z",
      snapshot: trashed,
      relationships: { collections: [] }
    }]
  };
  const path = "images/image-trashed.webp";
  const files = new Map([[path, new Blob(["good!"], { type: "image/webp" })]]);

  const parsed = await parseCompleteFolderBackup(source, files);
  const imported = mergeLibraryPackage({ entries: [] }, parsed);
  const restored = restoreTrashItems(imported.state, ["trash:entry:case:trashed"]);

  assert.deepEqual(parsed.trashState.items[0].snapshot.facetAssignments, []);
  assert.equal(parsed.importStats.droppedAiAssignments, 1);
  assert.equal(restored.entries.length, 1);
  assert.deepEqual(restored.entries[0].facetAssignments, []);
});

test("complete backup import drops broken AI labels attached to a trashed media relationship", async () => {
  const source = packageValue([entry("case:owner")]);
  source.trashState = {
    version: 1,
    items: [{
      id: "trash:media:case:owner:image:trashed-media",
      kind: "media",
      targetId: "image:trashed-media",
      deletedAt: "2026-08-26T01:00:00.000Z",
      snapshot: { mediaAssets: [image("image:trashed-media")] },
      relationships: {
        entryId: "case:owner",
        positions: [{ id: "image:trashed-media", index: 0 }],
        primaryMediaId: "image:trashed-media",
        facetAssignments: [{
          facetId: "missing-facet",
          nodeId: "missing-node",
          visualId: "image:trashed-media",
          status: "confirmed",
          source: "vision_model"
        }]
      }
    }]
  };
  const files = new Map([[
    "images/image-trashed-media.webp",
    new Blob(["good!"], { type: "image/webp" })
  ]]);

  const parsed = await parseCompleteFolderBackup(source, files);
  const imported = mergeLibraryPackage({ entries: [] }, parsed);
  const restored = restoreTrashItems(imported.state, ["trash:media:case:owner:image:trashed-media"]);

  assert.deepEqual(parsed.trashState.items[0].relationships.facetAssignments, []);
  assert.equal(parsed.importStats.droppedAiAssignments, 1);
  assert.deepEqual(restored.entries[0].facetAssignments, []);
  assert.deepEqual(restored.entries[0].mediaAssets.map((asset) => asset.id), ["image:trashed-media"]);
});

test("legacy facet assignments migrate inside trashed cases and media before restore", async () => {
  const source = packageValue([entry("case:owner")]);
  source.facetCatalog = {
    version: 1,
    revision: 1,
    facets: [{ id: "legacy:subject", name: "主体", order: 0 }],
    nodes: [{
      id: "legacy:character",
      facetId: "legacy:subject",
      parentId: null,
      name: "人物",
      aliases: [],
      order: 0,
      status: "active"
    }]
  };
  const legacyAssignment = {
    facetId: "legacy:subject",
    nodeId: "legacy:character",
    visualId: "image:legacy",
    status: "confirmed",
    source: "vision_model"
  };
  source.trashState = {
    version: 1,
    items: [
      {
        id: "trash:entry:case:legacy",
        kind: "entry",
        targetId: "case:legacy",
        deletedAt: "2026-08-26T01:00:00.000Z",
        snapshot: entry("case:legacy", {
          mediaAssets: [image("image:legacy")],
          primaryMediaId: "image:legacy",
          facetAssignments: [legacyAssignment]
        }),
        relationships: { collections: [] }
      },
      {
        id: "trash:media:case:owner:image:legacy-media",
        kind: "media",
        targetId: "image:legacy-media",
        deletedAt: "2026-08-26T01:00:00.000Z",
        snapshot: { mediaAssets: [image("image:legacy-media")] },
        relationships: {
          entryId: "case:owner",
          positions: [{ id: "image:legacy-media", index: 0 }],
          primaryMediaId: "image:legacy-media",
          facetAssignments: [{ ...legacyAssignment, visualId: "image:legacy-media" }]
        }
      }
    ]
  };
  const files = new Map([
    ["images/image-legacy.webp", new Blob(["good!"], { type: "image/webp" })],
    ["images/image-legacy-media.webp", new Blob(["good!"], { type: "image/webp" })]
  ]);

  const parsed = await parseCompleteFolderBackup(source, files);
  const imported = mergeLibraryPackage({ entries: [] }, parsed);
  const restored = restoreTrashItems(imported.state, [
    "trash:entry:case:legacy",
    "trash:media:case:owner:image:legacy-media"
  ]);
  const restoredAssignments = restored.entries.flatMap((item) => item.facetAssignments ?? []);
  const validFacetIds = new Set(parsed.facetCatalog.facets.map((item) => item.id));
  const validNodeIds = new Set(parsed.facetCatalog.nodes.map((item) => item.id));

  assert.equal(restoredAssignments.length, 2);
  assert.equal(restoredAssignments.every((item) => validFacetIds.has(item.facetId)), true);
  assert.equal(restoredAssignments.every((item) => validNodeIds.has(item.nodeId)), true);
  assert.equal(restoredAssignments.some((item) => item.nodeId === "legacy:character"), false);
});

function packageValue(entries) {
  return {
    format: "prompt-case-library",
    version: 5,
    schemaVersion: SCHEMA_VERSION,
    settings: {},
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: createDefaultFacetCatalog(),
    classificationRules: [],
    organizerState: { collections: [] },
    entries
  };
}

function entry(id, overrides = {}) {
  return {
    id,
    schemaVersion: SCHEMA_VERSION,
    title: id,
    text: `prompt ${id}`,
    savedAt: "2026-08-26T00:00:00.000Z",
    classification: { pathIds: [], status: "needs_review", source: "auto" },
    facetAssignments: [],
    mediaAssets: [],
    primaryMediaId: "",
    ...overrides
  };
}

function image(id) {
  return {
    id,
    kind: "image",
    storageMode: "managed",
    assetPath: `images/${id.replaceAll(":", "-")}.webp`,
    sourceFormat: "webp",
    mimeType: "image/webp",
    byteSize: 5,
    capturedAt: "2026-08-26T00:00:00.000Z"
  };
}