@sundaeswap/sprinkles 0.3.0 → 0.5.0

package/src/Sprinkle/__tests__/show-menu.test.ts

@@ -1,15 +1,24 @@
-import { describe, expect, test, mock, beforeEach } from "bun:test";
+import { describe, expect, test, mock, beforeEach, spyOn } from "bun:test";
 import { Sprinkle, Type, type IMenu } from "../index.js";
 import { withProfile } from "./test-helpers.js";
 
 const mockSelect = mock();
 const mockInput = mock();
+const mockSelectCancellable = mock();
+const mockInputCancellable = mock();
 
 mock.module("@inquirer/prompts", () => ({
   select: mockSelect,
   input: mockInput,
 }));
 
+mock.module("../prompts.js", () => ({
+  selectCancellable: mockSelectCancellable,
+  inputCancellable: mockInputCancellable,
+  passwordCancellable: mock(),
+  confirmCancellable: mock(),
+}));
+
 describe("showMenu", () => {
   let sprinkle: Sprinkle<any>;
 
@@ -18,11 +27,12 @@ describe("showMenu", () => {
     sprinkle = withProfile(new Sprinkle(schema, "/tmp/test"));
     sprinkle.settings = { name: "test" } as any;
     mockSelect.mockClear();
+    mockSelectCancellable.mockClear();
     mockInput.mockClear();
   });
 
   test("exits when Exit is selected on main menu", async () => {
-    mockSelect.mockResolvedValueOnce(-1);
+    mockSelectCancellable.mockResolvedValueOnce(-1);
 
     const menu: IMenu<any> = {
       title: "Test Menu",
@@ -40,7 +50,7 @@ describe("showMenu", () => {
   test("executes action and re-shows menu", async () => {
     const actionFn = mock(async () => {});
 
-    mockSelect.mockResolvedValueOnce(0).mockResolvedValueOnce(-1);
+    mockSelectCancellable.mockResolvedValueOnce(0).mockResolvedValueOnce(-1);
 
     const menu: IMenu<any> = {
       title: "Test Menu",
@@ -57,7 +67,7 @@ describe("showMenu", () => {
   });
 
   test("main menu includes Settings & Profiles submenu and Exit", async () => {
-    mockSelect.mockResolvedValueOnce(-1);
+    mockSelectCancellable.mockResolvedValueOnce(-1);
 
     const menu: IMenu<any> = {
       title: "Test",
@@ -66,7 +76,7 @@ describe("showMenu", () => {
 
     await sprinkle.showMenu(menu);
 
-    const choices = mockSelect.mock.calls[0][0].choices;
+    const choices = mockSelectCancellable.mock.calls[0][0].choices;
     const names = choices.map((c: any) => c.name);
     expect(names).toContain("Settings & Profiles");
     expect(names).toContain("Exit");
@@ -76,7 +86,7 @@ describe("showMenu", () => {
   });
 
   test("submenu includes Back instead of Exit", async () => {
-    mockSelect
+    mockSelectCancellable
       .mockResolvedValueOnce(0)
       .mockResolvedValueOnce(-1)
       .mockResolvedValueOnce(-1);
@@ -93,7 +103,7 @@ describe("showMenu", () => {
 
     await sprinkle.showMenu(menu);
 
-    const subChoices = mockSelect.mock.calls[1][0].choices;
+    const subChoices = mockSelectCancellable.mock.calls[1][0].choices;
     const subNames = subChoices.map((c: any) => c.name);
     expect(subNames).toContain("Back");
     expect(subNames).not.toContain("Exit");
@@ -102,7 +112,7 @@ describe("showMenu", () => {
   test("action returning sprinkle instance saves settings", async () => {
     sprinkle.settings = { name: "original" } as any;
 
-    mockSelect.mockResolvedValueOnce(0).mockResolvedValueOnce(-1);
+    mockSelectCancellable.mockResolvedValueOnce(0).mockResolvedValueOnce(-1);
 
     const menu: IMenu<any> = {
       title: "Test",
@@ -120,4 +130,82 @@ describe("showMenu", () => {
     await sprinkle.showMenu(menu);
     expect(sprinkle.settings).toEqual({ name: "updated" });
   });
+
+  test("Settings submenu includes View settings option", async () => {
+    // Select "Settings & Profiles" (-5), then "Back" (-1), then "Exit" (-1)
+    mockSelectCancellable
+      .mockResolvedValueOnce(-5)  // Settings & Profiles
+      .mockResolvedValueOnce(-1)  // Back
+      .mockResolvedValueOnce(-1); // Exit
+
+    const menu: IMenu<any> = {
+      title: "Test",
+      items: [{ title: "Action", action: async () => {} }],
+    };
+
+    await sprinkle.showMenu(menu);
+
+    // Second call is the settings submenu
+    const settingsChoices = mockSelectCancellable.mock.calls[1][0].choices;
+    const settingsNames = settingsChoices.map((c: any) => c.name);
+    expect(settingsNames).toContain("View settings");
+  });
+
+  test("View settings displays masked settings", async () => {
+    const consoleSpy = spyOn(console, "log").mockImplementation(() => {});
+
+    // Select "Settings & Profiles" (-5), then "View settings" (0), then "Back" (-1), then "Exit" (-1)
+    mockSelectCancellable
+      .mockResolvedValueOnce(-5)  // Settings & Profiles
+      .mockResolvedValueOnce(0)   // View settings (first item)
+      .mockResolvedValueOnce(-1)  // Back
+      .mockResolvedValueOnce(-1); // Exit
+
+    const menu: IMenu<any> = {
+      title: "Test",
+      items: [{ title: "Action", action: async () => {} }],
+    };
+
+    await sprinkle.showMenu(menu);
+
+    // Should have called console.log with the settings
+    expect(consoleSpy).toHaveBeenCalled();
+    const output = consoleSpy.mock.calls[0][0];
+    expect(output).toContain("name");
+
+    consoleSpy.mockRestore();
+  });
+
+  test("Create profile restores state when FillInStruct is cancelled", async () => {
+    // Capture original state
+    const originalProfileId = sprinkle.currentProfile?.id;
+    const originalSettings = { ...sprinkle.settings };
+
+    // Settings menu indices: 0=View, 1=Edit, 2=Switch, 3=Create new profile
+    mockSelectCancellable
+      .mockResolvedValueOnce(-5)  // Settings & Profiles
+      .mockResolvedValueOnce(3);  // Create new profile
+
+    // promptProfileMeta: name then description
+    mockInputCancellable
+      .mockResolvedValueOnce("New Profile")  // Profile name
+      .mockResolvedValueOnce("")             // Profile description
+      .mockResolvedValueOnce(null);          // Cancel during FillInStruct (name field)
+
+    // After cancellation, back out of menus
+    mockSelectCancellable
+      .mockResolvedValueOnce(-1)  // Back from settings
+      .mockResolvedValueOnce(-1); // Exit
+
+    const menu: IMenu<any> = {
+      title: "Test",
+      items: [{ title: "Action", action: async () => {} }],
+    };
+
+    await sprinkle.showMenu(menu);
+
+    // State should be restored to original
+    expect(sprinkle.currentProfile?.id).toBe(originalProfileId);
+    expect(sprinkle.settings).toEqual(originalSettings);
+  });
 });

package/src/Sprinkle/__tests__/tx-dialog.test.ts

@@ -29,6 +29,27 @@ mock.module("@inquirer/prompts", () => ({
   search: mock(async () => "result"),
 }));
 
+// Mock cancellable prompts (used by TxDialog and other methods)
+mock.module("../prompts.js", () => ({
+  selectCancellable: mock(async (opts: any) => {
+    selectCalls.push(opts);
+    const response = selectResponses.shift();
+    if (response === undefined) {
+      return "cancel";
+    }
+    return response;
+  }),
+  inputCancellable: mock(async () => {
+    const response = inputResponses.shift();
+    return response ?? "";
+  }),
+  passwordCancellable: mock(async () => "secret"),
+  confirmCancellable: mock(async () => {
+    const response = confirmResponses.shift();
+    return response ?? false;
+  }),
+}));
+
 // Mock clipboardy
 let clipboardContent = "";
 let clipboardShouldFail = false;

package/src/Sprinkle/encryption.ts

@@ -0,0 +1,130 @@
+/**
+ * Encryption utilities for sensitive field handling.
+ * Functions for encrypting, decrypting, and masking sensitive data in settings.
+ */
+
+import type { TSchema } from "@sinclair/typebox";
+import { isObject, isUnion, isSensitive } from "./type-guards.js";
+import type { IEncryptionOptions } from "./types.js";
+
+/**
+ * Recursively collect paths to all sensitive fields in a schema.
+ */
+export function collectSensitivePaths(
+  type: TSchema,
+  prefix: string = "",
+): string[] {
+  const paths: string[] = [];
+  if (isObject(type)) {
+    const fields = type["properties"] as Record<string, TSchema>;
+    for (const [field, fieldType] of Object.entries(fields)) {
+      const fieldPath = prefix ? `${prefix}.${field}` : field;
+      if (isSensitive(fieldType)) {
+        paths.push(fieldPath);
+      }
+      paths.push(...collectSensitivePaths(fieldType, fieldPath));
+    }
+  }
+  if (isUnion(type)) {
+    for (const variant of type.anyOf) {
+      paths.push(...collectSensitivePaths(variant, prefix));
+    }
+  }
+  return paths;
+}
+
+/**
+ * Get a nested value from an object by dot-separated path.
+ */
+export function getNestedValue(obj: any, path: string): unknown {
+  return path.split(".").reduce((o, k) => o?.[k], obj);
+}
+
+/**
+ * Set a nested value in an object by dot-separated path.
+ */
+export function setNestedValue(obj: any, path: string, value: unknown): void {
+  const keys = path.split(".");
+  const last = keys.pop()!;
+  const parent = keys.reduce((o, k) => o?.[k], obj);
+  if (parent && typeof parent === "object") {
+    parent[last] = value;
+  }
+}
+
+/**
+ * JSON replacer that converts BigInt to string with 'n' suffix.
+ */
+export function bigIntReplacer(_key: string, value: unknown): unknown {
+  return typeof value === "bigint" ? `${value.toString()}n` : value;
+}
+
+/**
+ * JSON reviver that converts strings with 'n' suffix back to BigInt.
+ */
+export function bigIntReviver(_key: string, value: unknown): unknown {
+  if (typeof value === "string" && /^\d+n$/.test(value)) {
+    return BigInt(value.slice(0, -1));
+  }
+  return value;
+}
+
+/**
+ * Deep clone an object, preserving BigInt values.
+ */
+export function cloneWithBigInt<T>(obj: T): T {
+  return JSON.parse(JSON.stringify(obj, bigIntReplacer), bigIntReviver);
+}
+
+/**
+ * Encrypt all sensitive fields in a settings object.
+ */
+export function encryptSensitiveFields<T>(
+  settings: T,
+  type: TSchema,
+  encryption: IEncryptionOptions,
+): T {
+  const clone = cloneWithBigInt(settings);
+  const sensitivePaths = collectSensitivePaths(type);
+  for (const p of sensitivePaths) {
+    const value = getNestedValue(clone, p);
+    if (typeof value === "string" && value.length > 0) {
+      setNestedValue(clone, p, encryption.encrypt(value));
+    }
+  }
+  return clone;
+}
+
+/**
+ * Decrypt all sensitive fields in a settings object.
+ */
+export async function decryptSensitiveFields<T>(
+  settings: T,
+  type: TSchema,
+  encryption: IEncryptionOptions,
+): Promise<T> {
+  const clone = cloneWithBigInt(settings);
+  const sensitivePaths = collectSensitivePaths(type);
+  for (const p of sensitivePaths) {
+    const value = getNestedValue(clone, p);
+    if (typeof value === "string" && value.length > 0) {
+      setNestedValue(clone, p, await encryption.decrypt(value));
+    }
+  }
+  return clone;
+}
+
+/**
+ * Mask all sensitive fields in a settings object for display.
+ */
+export function maskSensitiveFields<T>(settings: T, type: TSchema): T {
+  const clone = cloneWithBigInt(settings);
+  const sensitivePaths = collectSensitivePaths(type);
+  for (const p of sensitivePaths) {
+    const value = getNestedValue(clone, p);
+    if (typeof value === "string" && value.length > 0) {
+      setNestedValue(clone, p, "********");
+    }
+  }
+  return clone;
+}