* `@noble/hashes` 1.7.1, `@scure/bip32` 1.6.2, `@scure/bip39` 1.5.4.

 *

 * SECRETS. This module returns the mnemonic from exactly one function,

 * {@link readSeedPhrase}, and derives from it in memory. It never logs and never

 * {@link loadSeed}, and derives from it in memory. It never logs and never

 * returns an `nsec` or a raw private key. The public manifest

 * {@link SeedIdentity} carries public identifiers only and is safe to print,

 * store, and export.

  delete: () => {},

};

/**

 * A keychain that lives for the length of one test, so the seal, open, and

 * migration paths are exercised for real without writing to the developer's own

 * keychain or depending on one existing.

 */

export const inMemoryKeyStore = (): SeedKeyStore => {

  let held: Uint8Array | undefined;

  return {

    available: () => true,

    get: () => held,

    put: (key) => {

      held = Uint8Array.from(key);

    },

    delete: () => {

      held = undefined;

    },

  };

};

/** True when the environment asks for the plaintext store. */

const plaintextRequested = (): boolean => {

  const value = (process.env[PLAINTEXT_ENV] ?? "").trim().toLowerCase();

};

/**

 * Read the stored seed and report what was protecting it. This and

 * {@link readSeedPhrase} are the only functions that return secret material.

 * Read the stored seed and report what was protecting it. It is the only

 * function in this module that returns secret material.

 */

export const loadSeed = (

  keyStore: SeedKeyStore = defaultSeedKeyStore(),

  return { phrase: openEnvelope(text, key, path), protection: "os_keychain" };

};

/**

 * Read the stored mnemonic. Every caller either derives from it or hands it to

 * the reader who asked for a backup. Returns `undefined` when no seed is stored.

 */

export const readSeedPhrase = (

  keyStore: SeedKeyStore = defaultSeedKeyStore(),

): string | undefined => {

  const stored = loadSeed(keyStore);

  return stored === undefined || stored.phrase.length === 0 ? undefined : stored.phrase;

};

const writeAtomic = (body: string): string => {

  const directory = seedDirectory();

  mkdirSync(directory, { recursive: true, mode: 0o700 });

  return { path: writeAtomic(`${sealPhrase(normalized, key)}\n`), protection };

};

/** {@link storeSeedPhrase}, for callers that only need the path. */

export const writeSeedPhrase = (

  phrase: string,

  keyStore: SeedKeyStore = defaultSeedKeyStore(),

): string => storeSeedPhrase(phrase, keyStore).path;

/**

 * Move a plaintext seed under the OS keychain, and report what is protecting it

 * afterwards. `undefined` when nothing is stored.

  generateSeedPhrase,

  identityKeychainCommandFor,

  IDENTITY_KEYCHAIN_SERVICE,

  inMemoryKeyStore,

  isValidSeedPhrase,

  loadSeed,

  noKeyStore,

  protectSeed,

  readSeedPhrase,

  seedEncryptedAtRest,

  seedPath,

  seedPresent,

  seedProtectionOnDisk,

  storeSeedPhrase,

  writeSeedPhrase,

  type SeedKeyStore,

} from "../src/seed-identity.js";

  walletDerivationPath: "m/44'/0'/0'/0/0",

} as const;

/**

 * A keychain that lives for the length of one test, so the seal, open, and

 * migration paths are exercised for real without writing to the developer's own

 * keychain or depending on one existing. It lives here rather than in `src`

 * because production has no use for it: the real stores are the OS keychain and

 * the plaintext file.

 */

const inMemoryKeyStore = (): SeedKeyStore => {

  let held: Uint8Array | undefined;

  return {

    available: () => true,

    get: () => held,

    put: (key) => {

      held = Uint8Array.from(key);

    },

    delete: () => {

      held = undefined;

    },

  };

};

const isolatedIdentityDirectory = () => {

  const directory = mkdtempSync(join(tmpdir(), "openagents-identity-"));

  process.env["OPENAGENTS_IDENTITY_DIR"] = directory;

  it("writes the phrase 0600 and reads it back unchanged", () => {

    isolatedIdentityDirectory();

    expect(seedPresent()).toBe(false);

    const path = writeSeedPhrase(`  ${TEST_PHRASE}  `, keys);

    const path = storeSeedPhrase(`  ${TEST_PHRASE}  `, keys).path;

    expect(path).toBe(seedPath());

    expect(seedPresent()).toBe(true);

    expect(statSync(path).mode & 0o777).toBe(0o600);

    expect(readSeedPhrase(keys)).toBe(TEST_PHRASE);

    expect(deriveSeedIdentity(readSeedPhrase(keys) ?? "").npub).toBe(FROZEN.npub);

    expect(loadSeed(keys)?.phrase).toBe(TEST_PHRASE);

    expect(deriveSeedIdentity(loadSeed(keys)?.phrase ?? "").npub).toBe(FROZEN.npub);

  });

  it("restores 0600 when the file on disk was left readable", () => {

    isolatedIdentityDirectory();

    const path = writeSeedPhrase(TEST_PHRASE, keys);

    const path = storeSeedPhrase(TEST_PHRASE, keys).path;

    chmodSync(path, 0o644);

    writeSeedPhrase(TEST_PHRASE, keys);

    storeSeedPhrase(TEST_PHRASE, keys);

    expect(statSync(path).mode & 0o777).toBe(0o600);

  });

  it("writes nothing when the phrase is not a valid mnemonic", () => {

    isolatedIdentityDirectory();

    expect(() => writeSeedPhrase("not a seed phrase at all", keys)).toThrow(/valid English BIP-39/);

    expect(() => storeSeedPhrase("not a seed phrase at all", keys)).toThrow(/valid English BIP-39/);

    expect(seedPresent()).toBe(false);

  });

  it("reports no seed for an absent or empty file, and forgets idempotently", () => {

    const directory = isolatedIdentityDirectory();

    expect(readSeedPhrase(keys)).toBeUndefined();

    expect(loadSeed(keys)?.phrase).toBeUndefined();

    expect(forgetSeedPhrase(keys)).toBe(false);

    writeFileSync(join(directory, "seed"), "   \n", { mode: 0o600 });

    expect(readSeedPhrase(keys)).toBeUndefined();

    writeSeedPhrase(TEST_PHRASE, keys);

    expect(loadSeed(keys)?.phrase).toBeUndefined();

    storeSeedPhrase(TEST_PHRASE, keys);

    expect(keys.get()).toBeDefined();

    expect(forgetSeedPhrase(keys)).toBe(true);

    expect(seedPresent()).toBe(false);

  it("keeps the seed out of the derived identity", () => {

    isolatedIdentityDirectory();

    writeSeedPhrase(TEST_PHRASE, keys);

    storeSeedPhrase(TEST_PHRASE, keys);

    const identity = deriveSeedIdentity(TEST_PHRASE);

    expect(JSON.stringify(identity)).not.toContain("abandon");

    expect(JSON.stringify(identity)).not.toContain("nsec");

    // The wrapping key is not in the identity directory. If it were, the file

    // and the key would travel together and the encryption would be theatre.

    expect(readdirSync(directory)).toEqual(["seed"]);

    expect(readSeedPhrase(keys)).toBe(TEST_PHRASE);

    expect(loadSeed(keys)?.phrase).toBe(TEST_PHRASE);

  });

  it("uses a fresh nonce for every seal", () => {

    const second = readFileSync(path, "utf8");

    expect(second).not.toBe(first);

    expect(readSeedPhrase(keys)).toBe(TEST_PHRASE);

    expect(loadSeed(keys)?.phrase).toBe(TEST_PHRASE);

  });

  /**

    keys.delete();

    expect(seedPresent()).toBe(true);

    expect(() => readSeedPhrase(keys)).toThrow(/encrypted/);

    expect(() => loadSeed(keys)).toThrow(/encrypted/);

    try {

      readSeedPhrase(keys);

      loadSeed(keys);

    } catch (cause) {

      expect(String(cause)).not.toContain("abandon");

    }

    storeSeedPhrase(TEST_PHRASE, keys);

    keys.put(new Uint8Array(32).fill(7));

    expect(() => readSeedPhrase(keys)).toThrow(/does not open it/);

    expect(() => loadSeed(keys)).toThrow(/does not open it/);

  });

  /**

    expect(protection).toBe("plaintext_file");

    expect(seedEncryptedAtRest(protection)).toBe(false);

    expect(readFileSync(path, "utf8")).toContain(TEST_PHRASE);

    expect(readSeedPhrase(noKeyStore)).toBe(TEST_PHRASE);

    expect(loadSeed(noKeyStore)?.phrase).toBe(TEST_PHRASE);

    expect(seedProtectionOnDisk()).toBe("plaintext_file");

    // The sentence a person sees must name the file and say what is not covered.

    expect(protectSeed(keys)).toBe("os_keychain");

    // The identity did not move.

    const after = deriveSeedIdentity(readSeedPhrase(keys) ?? "");

    const after = deriveSeedIdentity(loadSeed(keys)?.phrase ?? "");

    expect(after).toEqual(before);

    expect(after.npub).toBe(FROZEN.npub);

    expect(protectSeed(noKeyStore)).toBe("plaintext_file");

    expect(readFileSync(path, "utf8")).toContain(TEST_PHRASE);

    expect(readSeedPhrase(noKeyStore)).toBe(TEST_PHRASE);

    expect(loadSeed(noKeyStore)?.phrase).toBe(TEST_PHRASE);

  });

  /**

    const reader = inMemoryKeyStore();

    reader.put(key);

    expect(readSeedPhrase(reader)).toBe(TEST_PHRASE);

    expect(deriveSeedIdentity(readSeedPhrase(reader) ?? "").npub).toBe(FROZEN.npub);

    expect(loadSeed(reader)?.phrase).toBe(TEST_PHRASE);

    expect(deriveSeedIdentity(loadSeed(reader)?.phrase ?? "").npub).toBe(FROZEN.npub);

  });

  /**