feat: add atomic vault creation from adopted root key (v4.0.14)

@@ -0,0 +1,83 @@1+import { beforeEach, describe, expect, it, vi } from "vitest";2+import { computeVaultId } from "../shared/sync-identity";3+4+async function dispatch(message: { type: string; payload?: unknown }) {5+  vi.resetModules();6+  const messages = await import("./messages");7+  return messages.handleMessage(8+    message as never,9+    { url: chrome.runtime.getURL("popup.html") } as chrome.runtime.MessageSender,10+  );11+}12+13+describe("CREATE_VAULT_FROM_ROOT_KEY message", () => {14+  beforeEach(() => {15+    vi.stubGlobal("__PEACH_E2E_PASSKEYS__", false);16+    vi.stubGlobal("chrome", {17+      runtime: {18+        id: "ext",19+        getURL: (path = "") => `chrome-extension://ext/${path}`,20+      },21+      tabs: {22+        query: vi.fn((_query: unknown, callback?: (tabs: Array<{ id?: number }>) => void) => {23+          if (typeof callback === "function") callback([]);24+          return Promise.resolve([]);25+        }),26+        sendMessage: vi.fn(async () => ({ ok: true })),27+      },28+      storage: {29+        local: {30+          get: vi.fn(async () => ({})),31+          set: vi.fn(),32+          remove: vi.fn(),33+        },34+        session: { get: vi.fn(async () => ({})), set: vi.fn(), remove: vi.fn() },35+      },36+      alarms: { clear: vi.fn(), create: vi.fn(), onAlarm: { addListener: vi.fn() } },37+      idle: { setDetectionInterval: vi.fn(), onStateChanged: { addListener: vi.fn() } },38+    });39+  });40+41+  it("T-A06: succeeds with a valid receiver password and root key", async () => {42+    const res = await dispatch({43+      type: "CREATE_VAULT_FROM_ROOT_KEY",44+      payload: { password: "receiver-local-passphrase-456", rootKeyHex: "44".repeat(32) },45+    }) as { ok: boolean; vaultId?: string };46+47+    expect(res.ok).toBe(true);48+    expect(res.vaultId).toMatch(/^[0-9a-f]{64}$/);49+  });50+51+  it("T-A07: fails gracefully for invalid rootKeyHex", async () => {52+    const res = await dispatch({53+      type: "CREATE_VAULT_FROM_ROOT_KEY",54+      payload: { password: "receiver-local-passphrase-456", rootKeyHex: "nope" },55+    }) as { ok: boolean; error?: string };56+57+    expect(res.ok).toBe(false);58+    expect(res.error).toContain("ADOPT_INVALID_ROOT_KEY");59+  });60+61+  it("T-A08: is vault-less allowed", async () => {62+    const hasBefore = await dispatch({ type: "HAS_VAULT" }) as { ok: boolean; data?: boolean };63+    expect(hasBefore.data).toBe(false);64+65+    const create = await dispatch({66+      type: "CREATE_VAULT_FROM_ROOT_KEY",67+      payload: { password: "receiver-local-passphrase-456", rootKeyHex: "55".repeat(32) },68+    }) as { ok: boolean };69+70+    expect(create.ok).toBe(true);71+  });72+73+  it("T-A09: returns the vault id computed from the adopted root key", async () => {74+    const rootKeyHex = "66".repeat(32);75+    const expected = await computeVaultId(new Uint8Array(Buffer.from(rootKeyHex, "hex")));76+    const res = await dispatch({77+      type: "CREATE_VAULT_FROM_ROOT_KEY",78+      payload: { password: "receiver-local-passphrase-456", rootKeyHex },79+    }) as { ok: boolean; vaultId?: string };80+81+    expect(res).toEqual({ ok: true, vaultId: expected });82+  });83+});

@@ -0,0 +1,159 @@1+import { beforeEach, describe, expect, it, vi } from "vitest";2+import { computeVaultId } from "../shared/sync-identity";3+import type { StoredVault } from "../shared/types";4+5+type StorageShape = Record<string, unknown>;6+7+function makeChromeStorageMock(): { storage: StorageShape; chrome: typeof chrome } {8+  const storage: StorageShape = {};9+  const chromeMock = {10+    storage: {11+      local: {12+        get: vi.fn(async (key?: string | string[]) => {13+          if (!key) return { ...storage };14+          if (typeof key === "string") return { [key]: storage[key] };15+          return key.reduce<StorageShape>((acc, k) => {16+            acc[k] = storage[k];17+            return acc;18+          }, {});19+        }),20+        set: vi.fn(async (next: StorageShape) => {21+          Object.assign(storage, next);22+        }),23+        remove: vi.fn(async (keys: string | string[]) => {24+          for (const k of Array.isArray(keys) ? keys : [keys]) delete storage[k];25+        }),26+      },27+      session: { get: vi.fn(async () => ({})), set: vi.fn(), remove: vi.fn() },28+    },29+    alarms: { clear: vi.fn(), create: vi.fn(), onAlarm: { addListener: vi.fn() } },30+    idle: { setDetectionInterval: vi.fn(), onStateChanged: { addListener: vi.fn() } },31+  } as unknown as typeof chrome;32+  return { storage, chrome: chromeMock };33+}34+35+describe("vault adoption: createVaultFromRootKey", () => {36+  const SOURCE_PASSWORD = "source-adoption-passphrase-123";37+  const RECEIVER_PASSWORD = "receiver-local-passphrase-456";38+39+  beforeEach(() => {40+    vi.resetModules();41+    const mock = makeChromeStorageMock();42+    vi.stubGlobal("chrome", mock.chrome);43+    vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("no network"); }));44+  });45+46+  it("T-A01: round-trips an existing root key under a different local password", async () => {47+    const sourceVault = await import("./vault");48+    await sourceVault.createVault(SOURCE_PASSWORD);49+    const rootKeyHex = sourceVault.getRootKeyHex();50+    expect(rootKeyHex).toMatch(/^[0-9a-f]{64}$/);51+    const sourceVaultId = await computeVaultId(new Uint8Array(Buffer.from(rootKeyHex!, "hex")));52+53+    vi.resetModules();54+    const mock = makeChromeStorageMock();55+    vi.stubGlobal("chrome", mock.chrome);56+    const receiverVault = await import("./vault");57+    const result = await receiverVault.createVaultFromRootKey(RECEIVER_PASSWORD, rootKeyHex!);58+59+    expect(result.vaultId).toBe(sourceVaultId);60+    receiverVault.lock();61+    expect(await receiverVault.unlock(RECEIVER_PASSWORD)).toBe(true);62+    expect(receiverVault.getRootKeyHex()).toBe(rootKeyHex);63+  });64+65+  it("T-A02: recovery words match the source vault because they derive from the same root key prefix", async () => {66+    const sourceVault = await import("./vault");67+    await sourceVault.createVault(SOURCE_PASSWORD);68+    const rootKeyHex = sourceVault.getRootKeyHex()!;69+    const sourceWords = await sourceVault.getRecoveryWords();70+71+    vi.resetModules();72+    const mock = makeChromeStorageMock();73+    vi.stubGlobal("chrome", mock.chrome);74+    const receiverVault = await import("./vault");75+    await receiverVault.createVaultFromRootKey(RECEIVER_PASSWORD, rootKeyHex);76+77+    expect(await receiverVault.getRecoveryWords()).toEqual(sourceWords);78+  });79+80+  it.each([81+    ["63 chars", "a".repeat(63)],82+    ["65 chars", "a".repeat(65)],83+    ["uppercase", "A".repeat(64)],84+    ["non-hex", "g".repeat(64)],85+    ["empty", ""],86+  ])("T-A03: rejects invalid root key input: %s", async (_label, rootKeyHex) => {87+    const vault = await import("./vault");88+    await expect(vault.createVaultFromRootKey(RECEIVER_PASSWORD, rootKeyHex))89+      .rejects.toThrow(/ADOPT_INVALID_ROOT_KEY/);90+  });91+92+  it("T-A04: zeroes the decoded root key buffer on success and failure", async () => {93+    const fillSpy = vi.spyOn(Uint8Array.prototype, "fill");94+    const vault = await import("./vault");95+    await vault.createVaultFromRootKey(RECEIVER_PASSWORD, "11".repeat(32));96+    expect(fillSpy).toHaveBeenCalledWith(0);97+98+    vi.resetModules();99+    const mock = makeChromeStorageMock();100+    const storageSet = mock.chrome.storage.local.set as unknown as ReturnType<typeof vi.fn>;101+    storageSet.mockRejectedValueOnce(new Error("quota"));102+    vi.stubGlobal("chrome", mock.chrome);103+    const failingVault = await import("./vault");104+105+    fillSpy.mockClear();106+    await expect(failingVault.createVaultFromRootKey(RECEIVER_PASSWORD, "22".repeat(32))).rejects.toThrow();107+    expect(fillSpy).toHaveBeenCalledWith(0);108+  });109+110+  it("T-A05: adopted vault supports normal entry writes and keeps the original vault id", async () => {111+    const vault = await import("./vault");112+    const rootKeyHex = "33".repeat(32);113+    const { vaultId } = await vault.createVaultFromRootKey(RECEIVER_PASSWORD, rootKeyHex);114+    const entry = await vault.addEntry({115+      type: "login",116+      title: "Example",117+      url: "https://example.com",118+      username: "june",119+      password: "secret",120+    });121+122+    expect(vault.getEntries()).toContainEqual(expect.objectContaining({ id: entry.id, title: "Example" }));123+    expect(vaultId).toBe(await computeVaultId(new Uint8Array(Buffer.from(rootKeyHex, "hex"))));124+  });125+126+  it("T-A30: storage failure leaves the receiver vault-less with no partial slot", async () => {127+    const mock = makeChromeStorageMock();128+    const storageSet = mock.chrome.storage.local.set as unknown as ReturnType<typeof vi.fn>;129+    storageSet.mockRejectedValueOnce(new Error("quota"));130+    vi.stubGlobal("chrome", mock.chrome);131+    const vault = await import("./vault");132+133+    await expect(vault.createVaultFromRootKey(RECEIVER_PASSWORD, "77".repeat(32)))134+      .rejects.toThrow(/STORAGE_QUOTA_EXCEEDED|quota/);135+136+    expect(mock.storage.peach_vault_a).toBeUndefined();137+    expect(mock.storage.peach_vault_b).toBeUndefined();138+    expect(await vault.hasVault()).toBe(false);139+    expect(vault.isUnlocked()).toBe(false);140+  });141+142+  it("T-A30: commits slot A, slot B, and timestamp together", async () => {143+    const mock = makeChromeStorageMock();144+    vi.stubGlobal("chrome", mock.chrome);145+    const vault = await import("./vault");146+147+    await vault.createVaultFromRootKey(RECEIVER_PASSWORD, "88".repeat(32));148+149+    const storageSet = mock.chrome.storage.local.set as unknown as ReturnType<typeof vi.fn>;150+    const commitCall = storageSet.mock.calls.find(([payload]) => (151+      Boolean((payload as StorageShape).peach_vault_a) &&152+      Boolean((payload as StorageShape).peach_vault_b)153+    ));154+    expect(commitCall).toBeDefined();155+    expect((commitCall![0] as StorageShape).peach_vault_a).toMatchObject({ version: 1 } satisfies Partial<StoredVault>);156+    expect((commitCall![0] as StorageShape).peach_vault_b).toMatchObject({ version: 1 } satisfies Partial<StoredVault>);157+    expect((commitCall![0] as StorageShape).peach_last_modified_at).toEqual(expect.any(String));158+  });159+});