@sundaeswap/sprinkles 0.6.1 → 0.7.0

package/dist/esm/Sprinkle/__tests__/builtin-actions.test.js

@@ -0,0 +1,1107 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { Type } from "@sinclair/typebox";
+import { Sprinkle, getBuiltinActions } from "../index.js";
+// Helper: write a minimal profile file into a tmp storage directory
+function writeTestProfile(storagePath, id, name, settings, description) {
+  const dir = path.join(storagePath, "profiles");
+  fs.mkdirSync(dir, {
+    recursive: true
+  });
+  const meta = {
+    name,
+    description,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify({
+    meta,
+    settings,
+    defaults: {}
+  }, null, 2), "utf-8");
+}
+
+// Settings schema with a sensitive field for masking tests
+const TestSchema = Type.Object({
+  name: Type.String(),
+  token: Type.Optional(Type.String({
+    sensitive: true
+  }))
+});
+
+// Simple schema without sensitive fields
+const SimpleSchema = Type.Object({
+  name: Type.String()
+});
+
+// Helper: create a Sprinkle with a loaded profile ready for action execution
+async function makeSprinkle(storagePath, profileId = "default", settings = {
+  name: "tester"
+}) {
+  const sprinkle = new Sprinkle(SimpleSchema, storagePath);
+  writeTestProfile(storagePath, profileId, "Default", settings);
+  await sprinkle.loadProfile(profileId);
+  return sprinkle;
+}
+describe("getBuiltinActions", () => {
+  test("returns an array of 14 actions", () => {
+    const actions = getBuiltinActions();
+    expect(actions).toHaveLength(14);
+  });
+  test("all actions have a category", () => {
+    const actions = getBuiltinActions();
+    const validCategories = ["sprinkles", "wallet", "transaction"];
+    for (const action of actions) {
+      expect(validCategories).toContain(action.category);
+    }
+  });
+  test("returns actions with expected names", () => {
+    const names = getBuiltinActions().map(a => a.name);
+    expect(names).toContain("list-profiles");
+    expect(names).toContain("get-profile");
+    expect(names).toContain("set-profile");
+    expect(names).toContain("create-profile");
+    expect(names).toContain("delete-profile");
+    expect(names).toContain("get-settings");
+    expect(names).toContain("update-settings");
+  });
+  test("all actions have inputSchema and outputSchema", () => {
+    const actions = getBuiltinActions();
+    for (const action of actions) {
+      expect(action.inputSchema).toBeDefined();
+      expect(action.outputSchema).toBeDefined();
+    }
+  });
+  test("built-in actions can be registered on a Sprinkle instance", () => {
+    const sprinkle = new Sprinkle(SimpleSchema, os.tmpdir());
+    const actions = getBuiltinActions();
+    for (const action of actions) {
+      sprinkle.registerAction(action);
+    }
+    expect(sprinkle.listActions()).toHaveLength(14);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// list-profiles
+// ---------------------------------------------------------------------------
+
+describe("list-profiles action", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("returns empty profiles array when no profiles exist", async () => {
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.profiles).toEqual([]);
+    }
+  });
+  test("returns all profiles with expected fields", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.profiles).toHaveLength(2);
+      const names = result.data.profiles.map(p => p.name);
+      expect(names).toContain("Alice");
+      expect(names).toContain("Bob");
+    }
+  });
+  test("includes activeProfileId when a profile is loaded", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "tester"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.activeProfileId).toBe("default");
+    }
+  });
+  test("activeProfileId is undefined when no profile is loaded", async () => {
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.activeProfileId).toBeUndefined();
+    }
+  });
+  test("each profile entry contains id, name, createdAt, updatedAt", async () => {
+    writeTestProfile(tmpDir, "alpha", "Alpha Profile", {
+      name: "alpha"
+    }, "A profile");
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alpha");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      const profile = result.data.profiles[0];
+      expect(profile.id).toBe("alpha");
+      expect(profile.name).toBe("Alpha Profile");
+      expect(profile.description).toBe("A profile");
+      expect(profile.createdAt).toBeDefined();
+      expect(profile.updatedAt).toBeDefined();
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// get-profile
+// ---------------------------------------------------------------------------
+
+describe("get-profile action", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("returns profile metadata and settings for a valid id", async () => {
+    writeTestProfile(tmpDir, "myprofile", "My Profile", {
+      name: "hello"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("myprofile");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "myprofile"
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.id).toBe("myprofile");
+      expect(result.data.name).toBe("My Profile");
+      expect(result.data.settings).toBeDefined();
+    }
+  });
+  test("returns PROFILE_NOT_FOUND for unknown profile id", async () => {
+    writeTestProfile(tmpDir, "existing", "Existing", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("existing");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "no-such-profile"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("PROFILE_NOT_FOUND");
+    }
+  });
+  test("settings are returned when includeSensitive is not specified (defaults to masked)", async () => {
+    writeTestProfile(tmpDir, "prof1", "Prof1", {
+      name: "value"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("prof1");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "prof1"
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.settings).toBeDefined();
+    }
+  });
+  test("returns raw settings when includeSensitive is true", async () => {
+    writeTestProfile(tmpDir, "prof2", "Prof2", {
+      name: "raw-value"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("prof2");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "prof2",
+      includeSensitive: true
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.settings.name).toBe("raw-value");
+    }
+  });
+  test("error details include the requested id", async () => {
+    writeTestProfile(tmpDir, "existing", "Existing", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("existing");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "ghost"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.details).toMatchObject({
+        id: "ghost"
+      });
+    }
+  });
+  test("returns INVALID_PROFILE_ID for path traversal attempts", async () => {
+    writeTestProfile(tmpDir, "existing", "Existing", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("existing");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "../etc/passwd"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("INVALID_PROFILE_ID");
+    }
+  });
+  test("masks sensitive fields by default with TestSchema", async () => {
+    // Write profile with a sensitive token field
+    writeTestProfile(tmpDir, "sensitive-test", "Sensitive Test", {
+      name: "user",
+      token: "secret-api-key-12345"
+    });
+    const sprinkle = new Sprinkle(TestSchema, tmpDir);
+    await sprinkle.loadProfile("sensitive-test");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "sensitive-test"
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      // Token should be masked
+      expect(result.data.settings.token).toBe("********");
+      // Name should not be masked
+      expect(result.data.settings.name).toBe("user");
+    }
+  });
+  test("returns raw sensitive fields when includeSensitive is true with TestSchema", async () => {
+    writeTestProfile(tmpDir, "sensitive-raw", "Sensitive Raw", {
+      name: "user",
+      token: "my-secret-token"
+    });
+    const sprinkle = new Sprinkle(TestSchema, tmpDir);
+    await sprinkle.loadProfile("sensitive-raw");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "sensitive-raw",
+      includeSensitive: true
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      // Token should NOT be masked
+      expect(result.data.settings.token).toBe("my-secret-token");
+      expect(result.data.settings.name).toBe("user");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// set-profile
+// ---------------------------------------------------------------------------
+
+describe("set-profile action", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("switches active profile and returns id and name", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("set-profile", {
+      id: "bob"
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.id).toBe("bob");
+      expect(result.data.name).toBe("Bob");
+    }
+  });
+  test("active profile is actually changed after set-profile", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("set-profile", {
+      id: "bob"
+    });
+    expect(sprinkle.profileId).toBe("bob");
+  });
+  test("returns PROFILE_NOT_FOUND when switching to unknown profile", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("set-profile", {
+      id: "nobody"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("PROFILE_NOT_FOUND");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create-profile
+// ---------------------------------------------------------------------------
+
+describe("create-profile action", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("creates a new profile and returns id and name", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "New Profile"
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.name).toBe("New Profile");
+      expect(result.data.id).toBeDefined();
+    }
+  });
+  test("created profile file exists on disk", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "Disk Profile"
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      const profilePath = path.join(tmpDir, "profiles", `${result.data.id}.json`);
+      expect(fs.existsSync(profilePath)).toBe(true);
+    }
+  });
+  test("create-profile does NOT switch the active profile", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("create-profile", {
+      name: "Another Profile"
+    });
+    expect(sprinkle.profileId).toBe("default");
+  });
+  test("create-profile with optional description stores it", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "Described Profile",
+      description: "A detailed description"
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      const profilePath = path.join(tmpDir, "profiles", `${result.data.id}.json`);
+      const content = JSON.parse(fs.readFileSync(profilePath, "utf-8"));
+      expect(content.meta.description).toBe("A detailed description");
+    }
+  });
+  test("returns DUPLICATE_PROFILE error when name already exists", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "Default"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("DUPLICATE_PROFILE");
+    }
+  });
+  test("duplicate name check is case-insensitive", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "DEFAULT"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("DUPLICATE_PROFILE");
+    }
+  });
+  test("create-profile with initial settings writes them to disk", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "Preset Profile",
+      settings: {
+        name: "preset-name"
+      }
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      const profilePath = path.join(tmpDir, "profiles", `${result.data.id}.json`);
+      const content = JSON.parse(fs.readFileSync(profilePath, "utf-8"));
+      expect(content.settings.name).toBe("preset-name");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// delete-profile
+// ---------------------------------------------------------------------------
+
+describe("delete-profile action", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("deletes a profile and returns deleted:true with id", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("delete-profile", {
+      id: "bob"
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.deleted).toBe(true);
+      expect(result.data.id).toBe("bob");
+    }
+  });
+  test("profile file is removed from disk after deletion", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("delete-profile", {
+      id: "bob"
+    });
+    expect(fs.existsSync(path.join(tmpDir, "profiles", "bob.json"))).toBe(false);
+  });
+  test("returns PROFILE_NOT_FOUND when deleting a non-existent profile", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("delete-profile", {
+      id: "nobody"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("PROFILE_NOT_FOUND");
+    }
+  });
+  test("returns CANNOT_DELETE_ONLY_PROFILE when only one profile exists", async () => {
+    writeTestProfile(tmpDir, "only", "Only", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("only");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("delete-profile", {
+      id: "only"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("CANNOT_DELETE_ONLY_PROFILE");
+    }
+  });
+  test("returns CANNOT_DELETE_ACTIVE_PROFILE when deleting the active profile", async () => {
+    writeTestProfile(tmpDir, "active", "Active", {
+      name: "x"
+    });
+    writeTestProfile(tmpDir, "other", "Other", {
+      name: "y"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("active");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("delete-profile", {
+      id: "active"
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("CANNOT_DELETE_ACTIVE_PROFILE");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// get-settings
+// ---------------------------------------------------------------------------
+
+describe("get-settings action", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("returns settings, profileId, and profileName", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "Alice"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-settings", {});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.profileId).toBe("default");
+      expect(result.data.profileName).toBe("Default");
+      expect(result.data.settings).toBeDefined();
+    }
+  });
+  test("returns masked settings by default", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "Alice"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-settings", {});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      // For a schema without sensitive fields, settings pass through unchanged
+      expect(result.data.settings.name).toBe("Alice");
+    }
+  });
+  test("returns raw settings when includeSensitive is true", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "raw-user"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-settings", {
+      includeSensitive: true
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.settings.name).toBe("raw-user");
+    }
+  });
+  test("returns same settings whether includeSensitive is false or not provided (no sensitive fields)", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "same-user"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const [masked, raw] = await Promise.all([sprinkle.runAction("get-settings", {
+      includeSensitive: false
+    }), sprinkle.runAction("get-settings", {
+      includeSensitive: true
+    })]);
+    expect(masked.success).toBe(true);
+    expect(raw.success).toBe(true);
+    if (masked.success && raw.success) {
+      expect(masked.data.settings).toEqual(raw.data.settings);
+    }
+  });
+  test("settings match what was loaded from profile", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "prof", {
+      name: "expected-value"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-settings", {
+      includeSensitive: true
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.settings.name).toBe("expected-value");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// update-settings
+// ---------------------------------------------------------------------------
+
+describe("update-settings action", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("updates settings and returns masked settings with profileId", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "old-name"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("update-settings", {
+      settings: {
+        name: "new-name"
+      }
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.settings.name).toBe("new-name");
+      expect(result.data.profileId).toBe("default");
+    }
+  });
+  test("update persists settings in memory", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "before"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("update-settings", {
+      settings: {
+        name: "after"
+      }
+    });
+    expect(sprinkle.settings.name).toBe("after");
+  });
+  test("update persists settings to disk", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "before"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("update-settings", {
+      settings: {
+        name: "persisted"
+      }
+    });
+
+    // Read the saved file to verify persistence
+    const profilePath = path.join(tmpDir, "profiles", "default.json");
+    const content = JSON.parse(fs.readFileSync(profilePath, "utf-8"));
+    expect(content.settings.name).toBe("persisted");
+  });
+  test("returns VALIDATION_ERROR for settings that violate schema", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "valid"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+
+    // Removing required 'name' field should fail schema validation
+    const result = await sprinkle.runAction("update-settings", {
+      settings: {
+        name: 12345
+      } // name must be a string
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("VALIDATION_ERROR");
+    }
+  });
+  test("settings are not saved when validation fails", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "original"
+    });
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("update-settings", {
+      settings: {
+        name: 99
+      } // invalid: not a string
+    });
+
+    // Settings in memory should remain unchanged
+    expect(sprinkle.settings.name).toBe("original");
+  });
+  test("shallow merges settings - existing keys not in update are preserved", async () => {
+    // Use a schema with two optional keys to test merge behaviour
+    const TwoKeySchema = Type.Object({
+      name: Type.String(),
+      label: Type.Optional(Type.String())
+    });
+    writeTestProfile(tmpDir, "twokey", "TwoKey", {
+      name: "base",
+      label: "keep-me"
+    });
+    const sprinkle = new Sprinkle(TwoKeySchema, tmpDir);
+    await sprinkle.loadProfile("twokey");
+    for (const action of getBuiltinActions()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("update-settings", {
+      settings: {
+        name: "updated"
+      }
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.settings.name).toBe("updated");
+      expect(result.data.settings.label).toBe("keep-me");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sprinkle.getProfileById direct method tests
+// ---------------------------------------------------------------------------
+
+describe("Sprinkle.getProfileById", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("returns profile entry when id exists", () => {
+    writeTestProfile(tmpDir, "myid", "My Name", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    const entry = sprinkle.getProfileById("myid");
+    expect(entry).toBeDefined();
+    expect(entry.id).toBe("myid");
+    expect(entry.meta.name).toBe("My Name");
+  });
+  test("returns undefined when id does not exist", () => {
+    writeTestProfile(tmpDir, "real", "Real", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    expect(sprinkle.getProfileById("ghost")).toBeUndefined();
+  });
+  test("returns undefined when no profiles exist", () => {
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    expect(sprinkle.getProfileById("anything")).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sprinkle.createProfileNonInteractive direct method tests
+// ---------------------------------------------------------------------------
+
+describe("Sprinkle.createProfileNonInteractive", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("creates a profile file and returns IProfileEntry", async () => {
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    const entry = await sprinkle.createProfileNonInteractive("Test Profile");
+    expect(entry.id).toBeDefined();
+    expect(entry.meta.name).toBe("Test Profile");
+    const profilePath = path.join(tmpDir, "profiles", `${entry.id}.json`);
+    expect(fs.existsSync(profilePath)).toBe(true);
+  });
+  test("sanitizes name to form a valid id", async () => {
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    const entry = await sprinkle.createProfileNonInteractive("My New Profile!");
+    // sanitized: "my-new-profile"
+    expect(entry.id).toBe("my-new-profile");
+  });
+  test("uses findAvailableId to avoid collisions", async () => {
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    // "My Profile" sanitizes to "my-profile". Pre-create that file so
+    // findAvailableId must fall back to "my-profile-2".
+    writeTestProfile(tmpDir, "my-profile", "My Profile First", {
+      name: "x"
+    });
+    const entry = await sprinkle.createProfileNonInteractive("My Profile");
+    // "my-profile" is taken, so the entry id should become "my-profile-2"
+    expect(entry.id).toBe("my-profile-2");
+  });
+  test("throws DUPLICATE_PROFILE for same name (case-insensitive)", async () => {
+    writeTestProfile(tmpDir, "existing", "Existing Profile", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await expect(sprinkle.createProfileNonInteractive("existing profile")).rejects.toMatchObject({
+      code: "DUPLICATE_PROFILE"
+    });
+  });
+  test("stores optional description in meta", async () => {
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    const entry = await sprinkle.createProfileNonInteractive("Described", "My description");
+    expect(entry.meta.description).toBe("My description");
+    const profilePath = path.join(tmpDir, "profiles", `${entry.id}.json`);
+    const content = JSON.parse(fs.readFileSync(profilePath, "utf-8"));
+    expect(content.meta.description).toBe("My description");
+  });
+  test("stores initial settings when provided", async () => {
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    const entry = await sprinkle.createProfileNonInteractive("With Settings", undefined, {
+      name: "preset"
+    });
+    const profilePath = path.join(tmpDir, "profiles", `${entry.id}.json`);
+    const content = JSON.parse(fs.readFileSync(profilePath, "utf-8"));
+    expect(content.settings.name).toBe("preset");
+  });
+  test("does not change the active profile", async () => {
+    writeTestProfile(tmpDir, "active", "Active", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("active");
+    await sprinkle.createProfileNonInteractive("New One");
+    expect(sprinkle.profileId).toBe("active");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sprinkle.deleteProfileById direct method tests
+// ---------------------------------------------------------------------------
+
+describe("Sprinkle.deleteProfileById", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  test("removes the profile file from disk", () => {
+    writeTestProfile(tmpDir, "keep", "Keep", {
+      name: "x"
+    });
+    writeTestProfile(tmpDir, "remove", "Remove", {
+      name: "y"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    sprinkle.profileId = "keep";
+    sprinkle.profileMeta = {
+      name: "Keep",
+      createdAt: "",
+      updatedAt: ""
+    };
+    sprinkle.deleteProfileById("remove");
+    expect(fs.existsSync(path.join(tmpDir, "profiles", "remove.json"))).toBe(false);
+    expect(fs.existsSync(path.join(tmpDir, "profiles", "keep.json"))).toBe(true);
+  });
+  test("throws PROFILE_NOT_FOUND for unknown id", () => {
+    writeTestProfile(tmpDir, "alpha", "Alpha", {
+      name: "x"
+    });
+    writeTestProfile(tmpDir, "beta", "Beta", {
+      name: "y"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    sprinkle.profileId = "alpha";
+    sprinkle.profileMeta = {
+      name: "Alpha",
+      createdAt: "",
+      updatedAt: ""
+    };
+    expect(() => sprinkle.deleteProfileById("ghost")).toThrow();
+    try {
+      sprinkle.deleteProfileById("ghost");
+    } catch (e) {
+      expect(e.code).toBe("PROFILE_NOT_FOUND");
+    }
+  });
+  test("throws CANNOT_DELETE_ONLY_PROFILE when only one profile exists", () => {
+    writeTestProfile(tmpDir, "solo", "Solo", {
+      name: "x"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    sprinkle.profileId = "solo";
+    sprinkle.profileMeta = {
+      name: "Solo",
+      createdAt: "",
+      updatedAt: ""
+    };
+    expect(() => sprinkle.deleteProfileById("solo")).toThrow();
+    try {
+      sprinkle.deleteProfileById("solo");
+    } catch (e) {
+      expect(e.code).toBe("CANNOT_DELETE_ONLY_PROFILE");
+    }
+  });
+  test("throws CANNOT_DELETE_ACTIVE_PROFILE when deleting the active profile", () => {
+    writeTestProfile(tmpDir, "active", "Active", {
+      name: "x"
+    });
+    writeTestProfile(tmpDir, "other", "Other", {
+      name: "y"
+    });
+    const sprinkle = new Sprinkle(SimpleSchema, tmpDir);
+    sprinkle.profileId = "active";
+    sprinkle.profileMeta = {
+      name: "Active",
+      createdAt: "",
+      updatedAt: ""
+    };
+    expect(() => sprinkle.deleteProfileById("active")).toThrow();
+    try {
+      sprinkle.deleteProfileById("active");
+    } catch (e) {
+      expect(e.code).toBe("CANNOT_DELETE_ACTIVE_PROFILE");
+    }
+  });
+});
+//# sourceMappingURL=builtin-actions.test.js.map