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

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

import { createManualSyncController } from "../extension/manual-sync.js";
import { createRevisionSnapshot } from "../extension/sync-model.js";

test("a second unchanged manual sync performs zero media snapshot and metadata writes", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.upToDate, true);
  assert.deepEqual(fixture.counts(), {
    stateReads: 0,
    mediaReads: 0,
    mediaWrites: 0,
    mediaDeletes: 0,
    objectWrites: 0,
    objectReads: 0,
    snapshotWrites: 0,
    metadataWrites: 0
  });
  assert.equal(fixture.controller.status().state, "up-to-date");
});

test("legacy sync metadata recovers object references from revision records", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  fixture.meta.assetRefs = {};
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.upToDate, true);
  assert.equal(result.mediaCount, 1);
  assert.equal(fixture.counts().mediaReads, 0);
  assert.equal(fixture.counts().objectWrites, 0);
  assert.equal(fixture.counts().snapshotWrites, 0);
  assert.equal(fixture.counts().metadataWrites, 0);
});

test("only a newly added managed asset is read and uploaded", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  fixture.state.entries.push(entry("two", "asset:two"));
  fixture.media.set("asset:two", new Blob(["two"], { type: "image/webp" }));
  fixture.meta.localDirty = true;
  fixture.meta.dirtyAssetIds = ["asset:two"];
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.ok, true);
  assert.equal(result.upToDate, false);
  assert.equal(fixture.counts().mediaReads, 1);
  assert.equal(fixture.counts().objectWrites, 1);
  assert.equal(fixture.counts().snapshotWrites, 1);
  assert.equal(fixture.counts().metadataWrites, 1);
  assert.equal(result.changeSummary.byEntity.entry.added, 1);
  assert.equal(result.effects.localBusinessChanged, false);
});

test("metadata-only edits reuse the previous media object without reading its blob", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  fixture.state.entries[0].title = "renamed";
  fixture.meta.localDirty = true;
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.ok, true);
  assert.equal(fixture.counts().mediaReads, 0);
  assert.equal(fixture.counts().objectWrites, 0);
  assert.equal(fixture.counts().snapshotWrites, 1);
  assert.equal(fixture.counts().metadataWrites, 1);
  assert.equal(result.changeSummary.byEntity.entry.updated, 1);
  assert.equal(result.effects.localBusinessChanged, false);
});

test("a reverted local edit clears its pending marker without publishing a snapshot", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  fixture.meta.localDirty = true;
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.upToDate, true);
  assert.equal(fixture.counts().mediaReads, 0);
  assert.equal(fixture.counts().objectWrites, 0);
  assert.equal(fixture.counts().snapshotWrites, 0);
  assert.equal(fixture.counts().metadataWrites, 1);
  assert.equal(fixture.meta.localDirty, false);
});

test("remote additions report that local business data changed exactly once", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  const remotePrepared = state([entry("one", "asset:one"), entry("remote", "asset:remote")]);
  remotePrepared.entries[0].mediaAssets[0].syncObjectId = fixture.meta.assetRefs["asset:one"].objectId;
  remotePrepared.entries[0].mediaAssets[0].syncContentType = "image/webp";
  remotePrepared.entries[1].mediaAssets[0].syncObjectId = "b".repeat(64);
  remotePrepared.entries[1].mediaAssets[0].syncContentType = "image/webp";
  fixture.remoteSnapshots.push(await createRevisionSnapshot(remotePrepared, {
    deviceId: "device-b",
    logicalClock: fixture.meta.logicalClock + 1,
    baseSnapshot: {
      format: "prompt-director-sync-state",
      version: 1,
      records: fixture.meta.records
    }
  }));
  fixture.objects.set("b".repeat(64), new Blob(["remote"], { type: "image/webp" }));
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.ok, true);
  assert.equal(result.effects.localBusinessChanged, true);
  assert.equal(result.effects.localMediaCommitted, 1);
  assert.equal(result.appliedChangeSummary.byEntity.entry.added, 1);
  assert.equal(fixture.counts().mediaWrites, 1);
  assert.equal(fixture.state.entries.some((item) => item.id === "remote"), true);
});

test("cancel rolls media restoration back and exposes a stable canceled terminal state", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  const remoteState = state([entry("one", "asset:one"), entry("remote", "asset:remote")]);
  const remotePrepared = structuredClone(remoteState);
  remotePrepared.entries[0].mediaAssets[0].syncObjectId = fixture.meta.assetRefs["asset:one"].objectId;
  remotePrepared.entries[0].mediaAssets[0].syncContentType = "image/webp";
  remotePrepared.entries[1].mediaAssets[0].syncObjectId = "b".repeat(64);
  remotePrepared.entries[1].mediaAssets[0].syncContentType = "image/webp";
  fixture.remoteSnapshots.push(await createRevisionSnapshot(remotePrepared, {
    deviceId: "device-b",
    logicalClock: fixture.meta.logicalClock + 1,
    baseSnapshot: {
      format: "prompt-director-sync-state",
      version: 1,
      records: fixture.meta.records
    }
  }));
  fixture.objects.set("b".repeat(64), new Blob(["remote"], { type: "image/webp" }));
  fixture.resetCounts();
  fixture.pauseObjectRead = true;

  const pending = fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  await fixture.objectReadStarted;
  assert.equal(fixture.controller.cancel(), true);
  fixture.resumeObjectRead();
  const result = await pending;

  assert.equal(result.canceled, true);
  assert.equal(fixture.controller.status().state, "canceled");
  assert.equal(fixture.controller.status().active, false);
  assert.equal(fixture.controller.status().terminal, true);
  assert.equal(fixture.controller.status().pendingCount, 0);
  assert.equal(fixture.controller.status().runningCount, 0);
  assert.equal(fixture.media.has("asset:remote"), false);
  assert.equal(fixture.counts().snapshotWrites, 0);
  assert.equal(fixture.counts().metadataWrites, 0);
});

test("repeated start calls share one active manual run and never queue a second run", async () => {
  const fixture = await createFixture();
  fixture.pauseSnapshotList = true;
  const first = fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  await fixture.snapshotListStarted;
  const second = fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  assert.equal(first, second);
  assert.equal(fixture.controller.status().pendingCount, 0);
  assert.equal(fixture.controller.status().runningCount, 1);
  fixture.resumeSnapshotList();
  await first;
  assert.equal(fixture.listCalls, 1);
  assert.equal(fixture.controller.status().active, false);
});

test("cancel is rejected after the atomic commit point has started", async () => {
  const fixture = await createFixture();
  fixture.pauseCommit = true;
  const pending = fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  await fixture.commitStarted;

  assert.equal(fixture.controller.status().phase, "committing");
  assert.equal(fixture.controller.cancel(), false);
  fixture.resumeCommit();
  const result = await pending;
  assert.equal(result.ok, true);
  assert.equal(result.canceled, false);
  assert.equal(fixture.controller.status().state, "success");
});

test("remote deletion removes an orphaned local blob only after the business commit succeeds", async () => {
  const fixture = await syncedTwoEntryFixture();
  await addRemoteDeletionOfFirstEntry(fixture);
  fixture.failCommit = true;
  fixture.resetCounts();

  await assert.rejects(
    fixture.controller.start({ vault: fixture.vault, settings: fixture.settings }),
    /commit failed/
  );
  assert.equal(fixture.media.has("asset:one"), true);
  assert.equal(fixture.counts().mediaDeletes, 0);
});

test("failed orphan cleanup is persisted and retried by the next unchanged manual sync", async () => {
  const fixture = await syncedTwoEntryFixture();
  await addRemoteDeletionOfFirstEntry(fixture);
  fixture.failDeleteIds = new Set(["asset:one"]);
  fixture.resetCounts();

  const first = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(first.ok, true);
  assert.equal(fixture.state.entries.some((item) => item.id === "one"), false);
  assert.equal(fixture.media.has("asset:one"), true);
  assert.deepEqual(fixture.meta.pendingCleanupAssetIds, ["asset:one"]);

  fixture.failDeleteIds = new Set();
  fixture.resetCounts();
  const retry = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(retry.upToDate, true);
  assert.equal(fixture.media.has("asset:one"), false);
  assert.deepEqual(fixture.meta.pendingCleanupAssetIds, []);
  assert.equal(fixture.counts().mediaDeletes, 1);
  assert.equal(fixture.counts().snapshotWrites, 0);
});

test("replacement recovery media is protected from sync orphan cleanup", async () => {
  const fixture = await syncedTwoEntryFixture();
  fixture.state.libraryReplacementRecoveryPoint = {
    version: 1,
    id: "recovery:one",
    createdAt: "2026-08-23T00:00:00.000Z",
    state: state([entry("one", "asset:one")]),
    retainedAssetIds: ["asset:one"]
  };
  await addRemoteDeletionOfFirstEntry(fixture);
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.ok, true);
  assert.equal(fixture.state.entries.some((item) => item.id === "one"), false);
  assert.equal(fixture.media.has("asset:one"), true);
  assert.deepEqual(fixture.meta.pendingCleanupAssetIds, []);
  assert.equal(fixture.counts().mediaDeletes, 0);
});

test("sync retains independent copies in different folders and fetches both originals", async () => {
  const fixture = await createFixture();
  fixture.state.entries[0].title = "Same";
  fixture.state.entries[0].text = "Same";
  fixture.state.entries[0].mediaAssets[0].contentHash = "d".repeat(64);
  fixture.state.organizerState.collections.push({ id: "project:local", name: "Local", entryIds: ["one"] });
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  const remoteDuplicate = entry("remote", "asset:remote");
  remoteDuplicate.title = "Same";
  remoteDuplicate.text = "Same";
  remoteDuplicate.mediaAssets[0].contentHash = "d".repeat(64);
  const remotePrepared = state([structuredClone(fixture.state.entries[0]), remoteDuplicate]);
  remotePrepared.organizerState.collections = [
    { id: "project:local", name: "Local", entryIds: ["one"] },
    { id: "project:remote", name: "Remote", entryIds: ["remote"] }
  ];
  remotePrepared.entries[0].mediaAssets[0].syncObjectId = fixture.meta.assetRefs["asset:one"].objectId;
  remotePrepared.entries[0].mediaAssets[0].syncContentType = "image/webp";
  remotePrepared.entries[1].mediaAssets[0].syncObjectId = "b".repeat(64);
  remotePrepared.entries[1].mediaAssets[0].syncContentType = "image/webp";
  fixture.remoteSnapshots.push(await createRevisionSnapshot(remotePrepared, {
    deviceId: "device-b",
    logicalClock: fixture.meta.logicalClock + 1,
    baseSnapshot: {
      format: "prompt-director-sync-state",
      version: 2,
      records: fixture.meta.records
    }
  }));
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.ok, true);
  assert.deepEqual(fixture.state.entries.map((item) => item.id).sort(), ["one", "remote"]);
  assert.deepEqual(fixture.state.organizerState.collections.map((project) => project.entryIds), [["one"], ["remote"]]);
  assert.equal(fixture.counts().objectReads, 1);
  assert.equal(fixture.media.has("asset:remote"), true);
});

test("one missing unsynced media item is reported and removed without blocking healthy cases", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  fixture.state.entries.push(entry("broken", "asset:broken"), entry("healthy", "asset:healthy"));
  fixture.media.set("asset:healthy", new Blob(["healthy"], { type: "image/webp" }));
  fixture.meta.localDirty = true;
  fixture.meta.dirtyAssetIds = ["asset:broken", "asset:healthy"];
  fixture.resetCounts();

  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });

  assert.equal(result.ok, true);
  assert.equal(result.skippedMediaCount, 1);
  assert.deepEqual(result.skippedMedia.map((item) => item.assetId), ["asset:broken"]);
  assert.equal(fixture.state.entries.find((item) => item.id === "broken").text, "broken");
  assert.deepEqual(fixture.state.entries.find((item) => item.id === "broken").mediaAssets, []);
  assert.deepEqual(fixture.state.entries.find((item) => item.id === "healthy").mediaAssets.map((asset) => asset.id), ["asset:healthy"]);
  assert.equal(fixture.counts().objectWrites, 1);
  assert.equal(fixture.counts().snapshotWrites, 1);
});

test("a media storage read error still stops sync without committing partial salvage", async () => {
  const fixture = await createFixture();
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  fixture.state.entries.push(entry("io-error", "asset:io-error"));
  fixture.media.set("asset:io-error", new Blob(["still-present"], { type: "image/webp" }));
  fixture.meta.localDirty = true;
  fixture.meta.dirtyAssetIds = ["asset:io-error"];
  fixture.failReadIds = new Set(["asset:io-error"]);
  fixture.resetCounts();

  await assert.rejects(
    fixture.controller.start({ vault: fixture.vault, settings: fixture.settings }),
    /media read failed/
  );

  assert.equal(fixture.state.entries.some((item) => item.id === "io-error"), true);
  assert.equal(fixture.counts().snapshotWrites, 0);
  assert.equal(fixture.counts().metadataWrites, 0);
});

async function syncedTwoEntryFixture() {
  const fixture = await createFixture();
  fixture.state.entries.push(entry("two", "asset:two"));
  fixture.media.set("asset:two", new Blob(["two"], { type: "image/webp" }));
  fixture.meta.localDirty = true;
  fixture.meta.dirtyAssetIds = ["asset:two"];
  await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  return fixture;
}

async function addRemoteDeletionOfFirstEntry(fixture) {
  const remotePrepared = state([entry("two", "asset:two")]);
  remotePrepared.entries[0].mediaAssets[0].syncObjectId = fixture.meta.assetRefs["asset:two"].objectId;
  remotePrepared.entries[0].mediaAssets[0].syncContentType = "image/webp";
  fixture.remoteSnapshots.push(await createRevisionSnapshot(remotePrepared, {
    deviceId: "device-b",
    logicalClock: fixture.meta.logicalClock + 1,
    baseSnapshot: {
      format: "prompt-director-sync-state",
      version: 2,
      records: fixture.meta.records
    }
  }));
}

async function createFixture() {
  let count = emptyCounts();
  let stateValue = state([entry("one", "asset:one")]);
  let metaValue = { logicalClock: 0, records: {}, assetRefs: {}, localDirty: false, dirtyAssetIds: [] };
  const remoteSnapshots = [];
  const media = new Map([["asset:one", new Blob(["one"], { type: "image/webp" })]]);
  const objects = new Map();
  let pauseObjectRead = false;
  let resumeObjectRead;
  let objectReadStartedResolve;
  let objectReadStarted = new Promise((resolve) => { objectReadStartedResolve = resolve; });
  let pauseSnapshotList = false;
  let resumeSnapshotList;
  let snapshotListStartedResolve;
  let snapshotListStarted = new Promise((resolve) => { snapshotListStartedResolve = resolve; });
  let listCalls = 0;
  let pauseCommit = false;
  let resumeCommit;
  let commitStartedResolve;
  let commitStarted = new Promise((resolve) => { commitStartedResolve = resolve; });
  let failCommit = false;
  let failDeleteIds = new Set();
  let failReadIds = new Set();

  const controller = createManualSyncController({
    readState: async () => {
      count.stateReads += 1;
      return structuredClone(stateValue);
    },
    readMeta: async () => structuredClone(metaValue),
    listSnapshots: async (_vault, { signal } = {}) => {
      listCalls += 1;
      if (pauseSnapshotList) {
        snapshotListStartedResolve();
        await new Promise((resolve) => { resumeSnapshotList = resolve; });
      }
      signal?.throwIfAborted();
      return structuredClone(remoteSnapshots);
    },
    readMedia: async (id) => {
      count.mediaReads += 1;
      if (failReadIds.has(id)) throw new Error("media read failed");
      return media.get(id) ?? null;
    },
    writeMedia: async (id, blob) => {
      count.mediaWrites += 1;
      media.set(id, blob);
    },
    deleteMedia: async (id) => {
      count.mediaDeletes += 1;
      if (failDeleteIds.has(id)) throw new Error("delete failed");
      media.delete(id);
    },
    writeObject: async (_vault, blob, { signal } = {}) => {
      signal?.throwIfAborted();
      count.objectWrites += 1;
      const objectId = blob.size === 3 && await blob.text() === "one" ? "a".repeat(64) : "c".repeat(64);
      objects.set(objectId, blob);
      return objectId;
    },
    readObject: async (_vault, objectId, { signal } = {}) => {
      count.objectReads += 1;
      if (pauseObjectRead) {
        objectReadStartedResolve();
        await new Promise((resolve) => { resumeObjectRead = resolve; });
      }
      signal?.throwIfAborted();
      return objects.get(objectId);
    },
    writeSnapshot: async (_vault, snapshot) => {
      count.snapshotWrites += 1;
      remoteSnapshots.push(structuredClone(snapshot));
    },
    commit: async ({ state: nextState, meta }) => {
      if (pauseCommit) {
        commitStartedResolve();
        await new Promise((resolve) => { resumeCommit = resolve; });
      }
      if (failCommit) throw new Error("commit failed");
      count.metadataWrites += 1;
      stateValue = structuredClone(nextState);
      metaValue = structuredClone(meta);
    },
    now: () => "2026-08-23T00:00:00.000Z"
  });

  const fixture = {
    controller,
    vault: { header: { vaultId: "vault:one" } },
    settings: { enabled: true, vaultId: "vault:one", deviceId: "device-a", retentionCount: 10 },
    remoteSnapshots,
    media,
    objects,
    counts: () => ({ ...count }),
    resetCounts: () => { count = emptyCounts(); },
    get state() { return stateValue; },
    get meta() { return metaValue; },
    get objectReadStarted() { return objectReadStarted; },
    resumeObjectRead: () => resumeObjectRead?.(),
    get snapshotListStarted() { return snapshotListStarted; },
    resumeSnapshotList: () => resumeSnapshotList?.(),
    get listCalls() { return listCalls; }
  };
  Object.defineProperty(fixture, "pauseObjectRead", { set(value) { pauseObjectRead = value; } });
  Object.defineProperty(fixture, "pauseSnapshotList", { set(value) { pauseSnapshotList = value; } });
  Object.defineProperty(fixture, "pauseCommit", { set(value) { pauseCommit = value; } });
  Object.defineProperty(fixture, "failCommit", { set(value) { failCommit = value; } });
  Object.defineProperty(fixture, "failDeleteIds", { set(value) { failDeleteIds = value; } });
  Object.defineProperty(fixture, "failReadIds", { set(value) { failReadIds = value; } });
  Object.defineProperty(fixture, "commitStarted", { get() { return commitStarted; } });
  fixture.resumeCommit = () => resumeCommit?.();
  return fixture;
}

function emptyCounts() {
  return {
    stateReads: 0,
    mediaReads: 0,
    mediaWrites: 0,
    mediaDeletes: 0,
    objectWrites: 0,
    objectReads: 0,
    snapshotWrites: 0,
    metadataWrites: 0
  };
}

function state(entries = []) {
  return {
    entries,
    compoundCases: [],
    organizerState: { version: 4, collections: [] },
    taxonomy: { version: 14, revision: 1, nodes: [] },
    facetCatalog: { version: 1, revision: 1, facets: [], nodes: [] },
    classificationRules: [],
    composerSettings: {},
    composerSessions: [],
    creativeExperimentSettings: {},
    creativeRuns: [],
    creativeSkills: { version: 1, items: [] },
    trashState: { version: 1, items: [] },
    settings: { libraryTitle: "PromptDirector" }
  };
}

function entry(id, assetId) {
  return {
    id,
    title: id,
    text: id,
    schemaVersion: 14,
    mediaAssets: [{
      id: assetId,
      kind: "image",
      usage: "content",
      storageMode: "managed",
      mimeType: "image/webp",
      byteSize: id.length
    }],
    primaryMediaId: assetId
  };
}

test("folder migration recovery originals survive remote deletion and orphan cleanup", async () => {
  const fixture = await syncedTwoEntryFixture();
  fixture.state.folderOwnershipBackup = { state: state([entry("one", "asset:one")]) };
  await addRemoteDeletionOfFirstEntry(fixture);
  fixture.resetCounts();
  const result = await fixture.controller.start({ vault: fixture.vault, settings: fixture.settings });
  assert.equal(result.ok, true);
  assert.equal(fixture.state.entries.some(item => item.id === "one"), false);
  assert.equal(fixture.media.has("asset:one"), true);
  assert.equal(fixture.counts().mediaDeletes, 0);
});

test('readonly recovery records never publish old text or deletion into encrypted sync', async () => {
  const fixture = await createFixture();
  fixture.state.entries[0].vaultReadStatus = { readOnly: true, source: 'last-saved-recovery' };
  await assert.rejects(fixture.controller.start({ vault: fixture.vault, settings: fixture.settings }), { code: 'case_files_unavailable' });
  assert.equal(fixture.counts().snapshotWrites, 0); assert.equal(fixture.counts().metadataWrites, 0); assert.equal(fixture.counts().objectWrites, 0);
});