@sundaeswap/sprinkles 0.6.0 → 0.7.0

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

@@ -0,0 +1,1110 @@
+"use strict";
+
+var _bunTest = require("bun:test");
+var fs = _interopRequireWildcard(require("fs"));
+var path = _interopRequireWildcard(require("path"));
+var os = _interopRequireWildcard(require("os"));
+var _typebox = require("@sinclair/typebox");
+var _index = require("../index.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+// 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 = _typebox.Type.Object({
+  name: _typebox.Type.String(),
+  token: _typebox.Type.Optional(_typebox.Type.String({
+    sensitive: true
+  }))
+});
+
+// Simple schema without sensitive fields
+const SimpleSchema = _typebox.Type.Object({
+  name: _typebox.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 _index.Sprinkle(SimpleSchema, storagePath);
+  writeTestProfile(storagePath, profileId, "Default", settings);
+  await sprinkle.loadProfile(profileId);
+  return sprinkle;
+}
+(0, _bunTest.describe)("getBuiltinActions", () => {
+  (0, _bunTest.test)("returns an array of 14 actions", () => {
+    const actions = (0, _index.getBuiltinActions)();
+    (0, _bunTest.expect)(actions).toHaveLength(14);
+  });
+  (0, _bunTest.test)("all actions have a category", () => {
+    const actions = (0, _index.getBuiltinActions)();
+    const validCategories = ["sprinkles", "wallet", "transaction"];
+    for (const action of actions) {
+      (0, _bunTest.expect)(validCategories).toContain(action.category);
+    }
+  });
+  (0, _bunTest.test)("returns actions with expected names", () => {
+    const names = (0, _index.getBuiltinActions)().map(a => a.name);
+    (0, _bunTest.expect)(names).toContain("list-profiles");
+    (0, _bunTest.expect)(names).toContain("get-profile");
+    (0, _bunTest.expect)(names).toContain("set-profile");
+    (0, _bunTest.expect)(names).toContain("create-profile");
+    (0, _bunTest.expect)(names).toContain("delete-profile");
+    (0, _bunTest.expect)(names).toContain("get-settings");
+    (0, _bunTest.expect)(names).toContain("update-settings");
+  });
+  (0, _bunTest.test)("all actions have inputSchema and outputSchema", () => {
+    const actions = (0, _index.getBuiltinActions)();
+    for (const action of actions) {
+      (0, _bunTest.expect)(action.inputSchema).toBeDefined();
+      (0, _bunTest.expect)(action.outputSchema).toBeDefined();
+    }
+  });
+  (0, _bunTest.test)("built-in actions can be registered on a Sprinkle instance", () => {
+    const sprinkle = new _index.Sprinkle(SimpleSchema, os.tmpdir());
+    const actions = (0, _index.getBuiltinActions)();
+    for (const action of actions) {
+      sprinkle.registerAction(action);
+    }
+    (0, _bunTest.expect)(sprinkle.listActions()).toHaveLength(14);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// list-profiles
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("list-profiles action", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.test)("returns empty profiles array when no profiles exist", async () => {
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.profiles).toEqual([]);
+    }
+  });
+  (0, _bunTest.test)("returns all profiles with expected fields", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.profiles).toHaveLength(2);
+      const names = result.data.profiles.map(p => p.name);
+      (0, _bunTest.expect)(names).toContain("Alice");
+      (0, _bunTest.expect)(names).toContain("Bob");
+    }
+  });
+  (0, _bunTest.test)("includes activeProfileId when a profile is loaded", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "tester"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.activeProfileId).toBe("default");
+    }
+  });
+  (0, _bunTest.test)("activeProfileId is undefined when no profile is loaded", async () => {
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.activeProfileId).toBeUndefined();
+    }
+  });
+  (0, _bunTest.test)("each profile entry contains id, name, createdAt, updatedAt", async () => {
+    writeTestProfile(tmpDir, "alpha", "Alpha Profile", {
+      name: "alpha"
+    }, "A profile");
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alpha");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("list-profiles", {});
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      const profile = result.data.profiles[0];
+      (0, _bunTest.expect)(profile.id).toBe("alpha");
+      (0, _bunTest.expect)(profile.name).toBe("Alpha Profile");
+      (0, _bunTest.expect)(profile.description).toBe("A profile");
+      (0, _bunTest.expect)(profile.createdAt).toBeDefined();
+      (0, _bunTest.expect)(profile.updatedAt).toBeDefined();
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// get-profile
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("get-profile action", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.test)("returns profile metadata and settings for a valid id", async () => {
+    writeTestProfile(tmpDir, "myprofile", "My Profile", {
+      name: "hello"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("myprofile");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "myprofile"
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.id).toBe("myprofile");
+      (0, _bunTest.expect)(result.data.name).toBe("My Profile");
+      (0, _bunTest.expect)(result.data.settings).toBeDefined();
+    }
+  });
+  (0, _bunTest.test)("returns PROFILE_NOT_FOUND for unknown profile id", async () => {
+    writeTestProfile(tmpDir, "existing", "Existing", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("existing");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "no-such-profile"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("PROFILE_NOT_FOUND");
+    }
+  });
+  (0, _bunTest.test)("settings are returned when includeSensitive is not specified (defaults to masked)", async () => {
+    writeTestProfile(tmpDir, "prof1", "Prof1", {
+      name: "value"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("prof1");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "prof1"
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.settings).toBeDefined();
+    }
+  });
+  (0, _bunTest.test)("returns raw settings when includeSensitive is true", async () => {
+    writeTestProfile(tmpDir, "prof2", "Prof2", {
+      name: "raw-value"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("prof2");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "prof2",
+      includeSensitive: true
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.settings.name).toBe("raw-value");
+    }
+  });
+  (0, _bunTest.test)("error details include the requested id", async () => {
+    writeTestProfile(tmpDir, "existing", "Existing", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("existing");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "ghost"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.details).toMatchObject({
+        id: "ghost"
+      });
+    }
+  });
+  (0, _bunTest.test)("returns INVALID_PROFILE_ID for path traversal attempts", async () => {
+    writeTestProfile(tmpDir, "existing", "Existing", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("existing");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "../etc/passwd"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("INVALID_PROFILE_ID");
+    }
+  });
+  (0, _bunTest.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 _index.Sprinkle(TestSchema, tmpDir);
+    await sprinkle.loadProfile("sensitive-test");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "sensitive-test"
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      // Token should be masked
+      (0, _bunTest.expect)(result.data.settings.token).toBe("********");
+      // Name should not be masked
+      (0, _bunTest.expect)(result.data.settings.name).toBe("user");
+    }
+  });
+  (0, _bunTest.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 _index.Sprinkle(TestSchema, tmpDir);
+    await sprinkle.loadProfile("sensitive-raw");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-profile", {
+      id: "sensitive-raw",
+      includeSensitive: true
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      // Token should NOT be masked
+      (0, _bunTest.expect)(result.data.settings.token).toBe("my-secret-token");
+      (0, _bunTest.expect)(result.data.settings.name).toBe("user");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// set-profile
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("set-profile action", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.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 _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("set-profile", {
+      id: "bob"
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.id).toBe("bob");
+      (0, _bunTest.expect)(result.data.name).toBe("Bob");
+    }
+  });
+  (0, _bunTest.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 _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("set-profile", {
+      id: "bob"
+    });
+    (0, _bunTest.expect)(sprinkle.profileId).toBe("bob");
+  });
+  (0, _bunTest.test)("returns PROFILE_NOT_FOUND when switching to unknown profile", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("set-profile", {
+      id: "nobody"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("PROFILE_NOT_FOUND");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create-profile
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("create-profile action", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.test)("creates a new profile and returns id and name", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "New Profile"
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.name).toBe("New Profile");
+      (0, _bunTest.expect)(result.data.id).toBeDefined();
+    }
+  });
+  (0, _bunTest.test)("created profile file exists on disk", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "Disk Profile"
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      const profilePath = path.join(tmpDir, "profiles", `${result.data.id}.json`);
+      (0, _bunTest.expect)(fs.existsSync(profilePath)).toBe(true);
+    }
+  });
+  (0, _bunTest.test)("create-profile does NOT switch the active profile", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("create-profile", {
+      name: "Another Profile"
+    });
+    (0, _bunTest.expect)(sprinkle.profileId).toBe("default");
+  });
+  (0, _bunTest.test)("create-profile with optional description stores it", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "Described Profile",
+      description: "A detailed description"
+    });
+    (0, _bunTest.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"));
+      (0, _bunTest.expect)(content.meta.description).toBe("A detailed description");
+    }
+  });
+  (0, _bunTest.test)("returns DUPLICATE_PROFILE error when name already exists", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "Default"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("DUPLICATE_PROFILE");
+    }
+  });
+  (0, _bunTest.test)("duplicate name check is case-insensitive", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "DEFAULT"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("DUPLICATE_PROFILE");
+    }
+  });
+  (0, _bunTest.test)("create-profile with initial settings writes them to disk", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("default");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("create-profile", {
+      name: "Preset Profile",
+      settings: {
+        name: "preset-name"
+      }
+    });
+    (0, _bunTest.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"));
+      (0, _bunTest.expect)(content.settings.name).toBe("preset-name");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// delete-profile
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("delete-profile action", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.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 _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("delete-profile", {
+      id: "bob"
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.deleted).toBe(true);
+      (0, _bunTest.expect)(result.data.id).toBe("bob");
+    }
+  });
+  (0, _bunTest.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 _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("delete-profile", {
+      id: "bob"
+    });
+    (0, _bunTest.expect)(fs.existsSync(path.join(tmpDir, "profiles", "bob.json"))).toBe(false);
+  });
+  (0, _bunTest.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 _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("alice");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("delete-profile", {
+      id: "nobody"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("PROFILE_NOT_FOUND");
+    }
+  });
+  (0, _bunTest.test)("returns CANNOT_DELETE_ONLY_PROFILE when only one profile exists", async () => {
+    writeTestProfile(tmpDir, "only", "Only", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("only");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("delete-profile", {
+      id: "only"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("CANNOT_DELETE_ONLY_PROFILE");
+    }
+  });
+  (0, _bunTest.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 _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("active");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("delete-profile", {
+      id: "active"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("CANNOT_DELETE_ACTIVE_PROFILE");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// get-settings
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("get-settings action", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.test)("returns settings, profileId, and profileName", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "Alice"
+    });
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-settings", {});
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.profileId).toBe("default");
+      (0, _bunTest.expect)(result.data.profileName).toBe("Default");
+      (0, _bunTest.expect)(result.data.settings).toBeDefined();
+    }
+  });
+  (0, _bunTest.test)("returns masked settings by default", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "Alice"
+    });
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-settings", {});
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      // For a schema without sensitive fields, settings pass through unchanged
+      (0, _bunTest.expect)(result.data.settings.name).toBe("Alice");
+    }
+  });
+  (0, _bunTest.test)("returns raw settings when includeSensitive is true", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "raw-user"
+    });
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-settings", {
+      includeSensitive: true
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.settings.name).toBe("raw-user");
+    }
+  });
+  (0, _bunTest.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 (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const [masked, raw] = await Promise.all([sprinkle.runAction("get-settings", {
+      includeSensitive: false
+    }), sprinkle.runAction("get-settings", {
+      includeSensitive: true
+    })]);
+    (0, _bunTest.expect)(masked.success).toBe(true);
+    (0, _bunTest.expect)(raw.success).toBe(true);
+    if (masked.success && raw.success) {
+      (0, _bunTest.expect)(masked.data.settings).toEqual(raw.data.settings);
+    }
+  });
+  (0, _bunTest.test)("settings match what was loaded from profile", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "prof", {
+      name: "expected-value"
+    });
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("get-settings", {
+      includeSensitive: true
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.settings.name).toBe("expected-value");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// update-settings
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("update-settings action", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.test)("updates settings and returns masked settings with profileId", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "old-name"
+    });
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("update-settings", {
+      settings: {
+        name: "new-name"
+      }
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.settings.name).toBe("new-name");
+      (0, _bunTest.expect)(result.data.profileId).toBe("default");
+    }
+  });
+  (0, _bunTest.test)("update persists settings in memory", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "before"
+    });
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("update-settings", {
+      settings: {
+        name: "after"
+      }
+    });
+    (0, _bunTest.expect)(sprinkle.settings.name).toBe("after");
+  });
+  (0, _bunTest.test)("update persists settings to disk", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "before"
+    });
+    for (const action of (0, _index.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"));
+    (0, _bunTest.expect)(content.settings.name).toBe("persisted");
+  });
+  (0, _bunTest.test)("returns VALIDATION_ERROR for settings that violate schema", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "valid"
+    });
+    for (const action of (0, _index.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
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("VALIDATION_ERROR");
+    }
+  });
+  (0, _bunTest.test)("settings are not saved when validation fails", async () => {
+    const sprinkle = await makeSprinkle(tmpDir, "default", {
+      name: "original"
+    });
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    await sprinkle.runAction("update-settings", {
+      settings: {
+        name: 99
+      } // invalid: not a string
+    });
+
+    // Settings in memory should remain unchanged
+    (0, _bunTest.expect)(sprinkle.settings.name).toBe("original");
+  });
+  (0, _bunTest.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 = _typebox.Type.Object({
+      name: _typebox.Type.String(),
+      label: _typebox.Type.Optional(_typebox.Type.String())
+    });
+    writeTestProfile(tmpDir, "twokey", "TwoKey", {
+      name: "base",
+      label: "keep-me"
+    });
+    const sprinkle = new _index.Sprinkle(TwoKeySchema, tmpDir);
+    await sprinkle.loadProfile("twokey");
+    for (const action of (0, _index.getBuiltinActions)()) {
+      sprinkle.registerAction(action);
+    }
+    const result = await sprinkle.runAction("update-settings", {
+      settings: {
+        name: "updated"
+      }
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data.settings.name).toBe("updated");
+      (0, _bunTest.expect)(result.data.settings.label).toBe("keep-me");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sprinkle.getProfileById direct method tests
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("Sprinkle.getProfileById", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.test)("returns profile entry when id exists", () => {
+    writeTestProfile(tmpDir, "myid", "My Name", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    const entry = sprinkle.getProfileById("myid");
+    (0, _bunTest.expect)(entry).toBeDefined();
+    (0, _bunTest.expect)(entry.id).toBe("myid");
+    (0, _bunTest.expect)(entry.meta.name).toBe("My Name");
+  });
+  (0, _bunTest.test)("returns undefined when id does not exist", () => {
+    writeTestProfile(tmpDir, "real", "Real", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    (0, _bunTest.expect)(sprinkle.getProfileById("ghost")).toBeUndefined();
+  });
+  (0, _bunTest.test)("returns undefined when no profiles exist", () => {
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    (0, _bunTest.expect)(sprinkle.getProfileById("anything")).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sprinkle.createProfileNonInteractive direct method tests
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("Sprinkle.createProfileNonInteractive", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.test)("creates a profile file and returns IProfileEntry", async () => {
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    const entry = await sprinkle.createProfileNonInteractive("Test Profile");
+    (0, _bunTest.expect)(entry.id).toBeDefined();
+    (0, _bunTest.expect)(entry.meta.name).toBe("Test Profile");
+    const profilePath = path.join(tmpDir, "profiles", `${entry.id}.json`);
+    (0, _bunTest.expect)(fs.existsSync(profilePath)).toBe(true);
+  });
+  (0, _bunTest.test)("sanitizes name to form a valid id", async () => {
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    const entry = await sprinkle.createProfileNonInteractive("My New Profile!");
+    // sanitized: "my-new-profile"
+    (0, _bunTest.expect)(entry.id).toBe("my-new-profile");
+  });
+  (0, _bunTest.test)("uses findAvailableId to avoid collisions", async () => {
+    const sprinkle = new _index.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"
+    (0, _bunTest.expect)(entry.id).toBe("my-profile-2");
+  });
+  (0, _bunTest.test)("throws DUPLICATE_PROFILE for same name (case-insensitive)", async () => {
+    writeTestProfile(tmpDir, "existing", "Existing Profile", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await (0, _bunTest.expect)(sprinkle.createProfileNonInteractive("existing profile")).rejects.toMatchObject({
+      code: "DUPLICATE_PROFILE"
+    });
+  });
+  (0, _bunTest.test)("stores optional description in meta", async () => {
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    const entry = await sprinkle.createProfileNonInteractive("Described", "My description");
+    (0, _bunTest.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"));
+    (0, _bunTest.expect)(content.meta.description).toBe("My description");
+  });
+  (0, _bunTest.test)("stores initial settings when provided", async () => {
+    const sprinkle = new _index.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"));
+    (0, _bunTest.expect)(content.settings.name).toBe("preset");
+  });
+  (0, _bunTest.test)("does not change the active profile", async () => {
+    writeTestProfile(tmpDir, "active", "Active", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    await sprinkle.loadProfile("active");
+    await sprinkle.createProfileNonInteractive("New One");
+    (0, _bunTest.expect)(sprinkle.profileId).toBe("active");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sprinkle.deleteProfileById direct method tests
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("Sprinkle.deleteProfileById", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-builtin-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  (0, _bunTest.test)("removes the profile file from disk", () => {
+    writeTestProfile(tmpDir, "keep", "Keep", {
+      name: "x"
+    });
+    writeTestProfile(tmpDir, "remove", "Remove", {
+      name: "y"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    sprinkle.profileId = "keep";
+    sprinkle.profileMeta = {
+      name: "Keep",
+      createdAt: "",
+      updatedAt: ""
+    };
+    sprinkle.deleteProfileById("remove");
+    (0, _bunTest.expect)(fs.existsSync(path.join(tmpDir, "profiles", "remove.json"))).toBe(false);
+    (0, _bunTest.expect)(fs.existsSync(path.join(tmpDir, "profiles", "keep.json"))).toBe(true);
+  });
+  (0, _bunTest.test)("throws PROFILE_NOT_FOUND for unknown id", () => {
+    writeTestProfile(tmpDir, "alpha", "Alpha", {
+      name: "x"
+    });
+    writeTestProfile(tmpDir, "beta", "Beta", {
+      name: "y"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    sprinkle.profileId = "alpha";
+    sprinkle.profileMeta = {
+      name: "Alpha",
+      createdAt: "",
+      updatedAt: ""
+    };
+    (0, _bunTest.expect)(() => sprinkle.deleteProfileById("ghost")).toThrow();
+    try {
+      sprinkle.deleteProfileById("ghost");
+    } catch (e) {
+      (0, _bunTest.expect)(e.code).toBe("PROFILE_NOT_FOUND");
+    }
+  });
+  (0, _bunTest.test)("throws CANNOT_DELETE_ONLY_PROFILE when only one profile exists", () => {
+    writeTestProfile(tmpDir, "solo", "Solo", {
+      name: "x"
+    });
+    const sprinkle = new _index.Sprinkle(SimpleSchema, tmpDir);
+    sprinkle.profileId = "solo";
+    sprinkle.profileMeta = {
+      name: "Solo",
+      createdAt: "",
+      updatedAt: ""
+    };
+    (0, _bunTest.expect)(() => sprinkle.deleteProfileById("solo")).toThrow();
+    try {
+      sprinkle.deleteProfileById("solo");
+    } catch (e) {
+      (0, _bunTest.expect)(e.code).toBe("CANNOT_DELETE_ONLY_PROFILE");
+    }
+  });
+  (0, _bunTest.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 _index.Sprinkle(SimpleSchema, tmpDir);
+    sprinkle.profileId = "active";
+    sprinkle.profileMeta = {
+      name: "Active",
+      createdAt: "",
+      updatedAt: ""
+    };
+    (0, _bunTest.expect)(() => sprinkle.deleteProfileById("active")).toThrow();
+    try {
+      sprinkle.deleteProfileById("active");
+    } catch (e) {
+      (0, _bunTest.expect)(e.code).toBe("CANNOT_DELETE_ACTIVE_PROFILE");
+    }
+  });
+});
+//# sourceMappingURL=builtin-actions.test.js.map