@sundaeswap/sprinkles 0.6.1 → 0.7.0

package/dist/cjs/Sprinkle/__tests__/cli-adapter.test.js

@@ -0,0 +1,722 @@
+"use strict";
+
+var _bunTest = require("bun:test");
+var _typebox = require("@sinclair/typebox");
+var _index = require("../actions/index.js");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+// Minimal Sprinkle-shaped mock for runCli tests
+function makeMockSprinkle(actions) {
+  const map = new Map(actions.map(a => [a.name, a]));
+  return {
+    getAction: name => map.get(name),
+    listActions: () => actions
+  };
+}
+
+// Lightweight stub context (runCli forwards it to executeAction)
+const fakeContext = {};
+
+// ---------------------------------------------------------------------------
+// camelToKebab
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("camelToKebab", () => {
+  (0, _bunTest.test)("converts simple camelCase to kebab-case", () => {
+    (0, _bunTest.expect)((0, _index.camelToKebab)("myFlagName")).toBe("my-flag-name");
+  });
+  (0, _bunTest.test)("converts single transition", () => {
+    (0, _bunTest.expect)((0, _index.camelToKebab)("getBalance")).toBe("get-balance");
+  });
+  (0, _bunTest.test)("leaves already-lowercase string unchanged", () => {
+    (0, _bunTest.expect)((0, _index.camelToKebab)("transfer")).toBe("transfer");
+  });
+  (0, _bunTest.test)("returns empty string unchanged", () => {
+    (0, _bunTest.expect)((0, _index.camelToKebab)("")).toBe("");
+  });
+  (0, _bunTest.test)("handles a single uppercase letter at start", () => {
+    // Leading dash is stripped
+    (0, _bunTest.expect)((0, _index.camelToKebab)("X")).toBe("x");
+  });
+  (0, _bunTest.test)("handles consecutive uppercase letters", () => {
+    // Each uppercase letter gets its own dash
+    (0, _bunTest.expect)((0, _index.camelToKebab)("URL")).toBe("u-r-l");
+  });
+  (0, _bunTest.test)("handles single lowercase character", () => {
+    (0, _bunTest.expect)((0, _index.camelToKebab)("a")).toBe("a");
+  });
+  (0, _bunTest.test)("handles string with digit (no conversion on digits)", () => {
+    (0, _bunTest.expect)((0, _index.camelToKebab)("action2Name")).toBe("action2-name");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// kebabToCamel
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("kebabToCamel", () => {
+  (0, _bunTest.test)("converts simple kebab-case to camelCase", () => {
+    (0, _bunTest.expect)((0, _index.kebabToCamel)("my-flag-name")).toBe("myFlagName");
+  });
+  (0, _bunTest.test)("converts single segment", () => {
+    (0, _bunTest.expect)((0, _index.kebabToCamel)("transfer")).toBe("transfer");
+  });
+  (0, _bunTest.test)("returns empty string unchanged", () => {
+    (0, _bunTest.expect)((0, _index.kebabToCamel)("")).toBe("");
+  });
+  (0, _bunTest.test)("converts digit after dash to uppercase... no: digit stays", () => {
+    // Digits after dash: char stays as-is (toUpperCase of a digit is itself)
+    (0, _bunTest.expect)((0, _index.kebabToCamel)("action-2-name")).toBe("action2Name");
+  });
+  (0, _bunTest.test)("is inverse of camelToKebab for simple identifiers", () => {
+    const original = "myFlagName";
+    (0, _bunTest.expect)((0, _index.kebabToCamel)((0, _index.camelToKebab)(original))).toBe(original);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// coerceValue
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("coerceValue", () => {
+  // Number
+  (0, _bunTest.test)("coerces string to number", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("3.14", _typebox.Type.Number())).toBe(3.14);
+  });
+  (0, _bunTest.test)("passes through numeric value unchanged", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(42, _typebox.Type.Number())).toBe(42);
+  });
+  (0, _bunTest.test)("returns non-numeric string as-is for Number schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("abc", _typebox.Type.Number())).toBe("abc");
+  });
+
+  // Integer
+  (0, _bunTest.test)("coerces string to integer via parseInt", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("7", _typebox.Type.Integer())).toBe(7);
+  });
+  (0, _bunTest.test)("truncates float number to integer", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(3.9, _typebox.Type.Integer())).toBe(3);
+  });
+  (0, _bunTest.test)("returns non-numeric string as-is for Integer schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("xyz", _typebox.Type.Integer())).toBe("xyz");
+  });
+
+  // Boolean
+  (0, _bunTest.test)("coerces string 'true' to boolean true", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("true", _typebox.Type.Boolean())).toBe(true);
+  });
+  (0, _bunTest.test)("coerces string 'false' to boolean false", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("false", _typebox.Type.Boolean())).toBe(false);
+  });
+  (0, _bunTest.test)("passes through boolean true unchanged", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(true, _typebox.Type.Boolean())).toBe(true);
+  });
+  (0, _bunTest.test)("passes through boolean false unchanged", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(false, _typebox.Type.Boolean())).toBe(false);
+  });
+  (0, _bunTest.test)("returns non-boolean string as-is for Boolean schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("yes", _typebox.Type.Boolean())).toBe("yes");
+  });
+
+  // BigInt
+  (0, _bunTest.test)("coerces string to BigInt", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("12345", _typebox.Type.BigInt())).toBe(BigInt("12345"));
+  });
+  (0, _bunTest.test)("coerces number to BigInt", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(99, _typebox.Type.BigInt())).toBe(BigInt(99));
+  });
+  (0, _bunTest.test)("passes through BigInt unchanged", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(BigInt(42), _typebox.Type.BigInt())).toBe(BigInt(42));
+  });
+  (0, _bunTest.test)("returns invalid BigInt string as-is", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("not-a-number", _typebox.Type.BigInt())).toBe("not-a-number");
+  });
+
+  // String
+  (0, _bunTest.test)("passes through string value unchanged", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("hello", _typebox.Type.String())).toBe("hello");
+  });
+  (0, _bunTest.test)("converts number to string for String schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(42, _typebox.Type.String())).toBe("42");
+  });
+
+  // Array
+  (0, _bunTest.test)("wraps single value in array", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("a", _typebox.Type.Array(_typebox.Type.String()))).toEqual(["a"]);
+  });
+  (0, _bunTest.test)("passes through existing array", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(["a", "b"], _typebox.Type.Array(_typebox.Type.String()))).toEqual(["a", "b"]);
+  });
+  (0, _bunTest.test)("coerces items in existing array against item schema", () => {
+    const result = (0, _index.coerceValue)(["1", "2"], _typebox.Type.Array(_typebox.Type.Integer()));
+    (0, _bunTest.expect)(result).toEqual([1, 2]);
+  });
+  (0, _bunTest.test)("coerces single value and applies item schema", () => {
+    const result = (0, _index.coerceValue)("5", _typebox.Type.Array(_typebox.Type.Number()));
+    (0, _bunTest.expect)(result).toEqual([5]);
+  });
+
+  // Object
+  (0, _bunTest.test)("parses JSON string for Object schema", () => {
+    const result = (0, _index.coerceValue)('{"id":"abc","count":3}', _typebox.Type.Object({
+      id: _typebox.Type.String(),
+      count: _typebox.Type.Number()
+    }));
+    (0, _bunTest.expect)(result).toEqual({
+      id: "abc",
+      count: 3
+    });
+  });
+  (0, _bunTest.test)("passes through non-JSON string for Object schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("not-json", _typebox.Type.Object({
+      x: _typebox.Type.String()
+    }))).toBe("not-json");
+  });
+  (0, _bunTest.test)("returns already-parsed object as-is for Object schema", () => {
+    const obj = {
+      x: 1
+    };
+    (0, _bunTest.expect)((0, _index.coerceValue)(obj, _typebox.Type.Object({
+      x: _typebox.Type.Number()
+    }))).toBe(obj);
+  });
+  (0, _bunTest.test)("returns malformed JSON string as-is for Object schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("{bad", _typebox.Type.Object({
+      x: _typebox.Type.String()
+    }))).toBe("{bad");
+  });
+
+  // Null / undefined passthrough
+  (0, _bunTest.test)("returns null as-is regardless of schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(null, _typebox.Type.String())).toBeNull();
+  });
+  (0, _bunTest.test)("returns undefined as-is regardless of schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)(undefined, _typebox.Type.Number())).toBeUndefined();
+  });
+
+  // Optional wrapper: TypeBox Optional<T> does not change Kind
+  (0, _bunTest.test)("coerces value correctly for Optional-wrapped schema", () => {
+    (0, _bunTest.expect)((0, _index.coerceValue)("42", _typebox.Type.Optional(_typebox.Type.Integer()))).toBe(42);
+  });
+
+  // Union: passthrough
+  (0, _bunTest.test)("passes through value for Union schema", () => {
+    const result = (0, _index.coerceValue)("hello", _typebox.Type.Union([_typebox.Type.String(), _typebox.Type.Number()]));
+    (0, _bunTest.expect)(result).toBe("hello");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseArgvWithSchema
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("parseArgvWithSchema", () => {
+  const schema = _typebox.Type.Object({
+    name: _typebox.Type.String(),
+    count: _typebox.Type.Integer(),
+    active: _typebox.Type.Boolean()
+  });
+  (0, _bunTest.test)("coerces string args according to schema types", () => {
+    const result = (0, _index.parseArgvWithSchema)({
+      name: "alice",
+      count: "5",
+      active: "true"
+    }, schema);
+    (0, _bunTest.expect)(result.name).toBe("alice");
+    (0, _bunTest.expect)(result.count).toBe(5);
+    (0, _bunTest.expect)(result.active).toBe(true);
+  });
+  (0, _bunTest.test)("maps kebab-case arg names to camelCase property names", () => {
+    const s = _typebox.Type.Object({
+      myFlag: _typebox.Type.String()
+    });
+    const result = (0, _index.parseArgvWithSchema)({
+      "my-flag": "hello"
+    }, s);
+    (0, _bunTest.expect)(result.myFlag).toBe("hello");
+  });
+  (0, _bunTest.test)("prefers camelCase lookup over kebab-case when both present", () => {
+    const s = _typebox.Type.Object({
+      myFlag: _typebox.Type.String()
+    });
+    const result = (0, _index.parseArgvWithSchema)({
+      myFlag: "camel",
+      "my-flag": "kebab"
+    }, s);
+    (0, _bunTest.expect)(result.myFlag).toBe("camel");
+  });
+  (0, _bunTest.test)("applies TypeBox defaults for omitted optional fields", () => {
+    const s = _typebox.Type.Object({
+      name: _typebox.Type.String(),
+      retries: _typebox.Type.Optional(_typebox.Type.Integer({
+        default: 3
+      }))
+    });
+    const result = (0, _index.parseArgvWithSchema)({
+      name: "test"
+    }, s);
+    (0, _bunTest.expect)(result.retries).toBe(3);
+  });
+  (0, _bunTest.test)("omits field with no default when not supplied", () => {
+    const s = _typebox.Type.Object({
+      name: _typebox.Type.String(),
+      extra: _typebox.Type.Optional(_typebox.Type.String())
+    });
+    const result = (0, _index.parseArgvWithSchema)({
+      name: "hello"
+    }, s);
+    (0, _bunTest.expect)("extra" in result).toBe(false);
+  });
+  (0, _bunTest.test)("returns raw args unchanged for non-object schema", () => {
+    const raw = {
+      foo: "bar"
+    };
+    const result = (0, _index.parseArgvWithSchema)(raw, _typebox.Type.String());
+    (0, _bunTest.expect)(result).toBe(raw);
+  });
+  (0, _bunTest.test)("coerces BigInt field from string", () => {
+    const s = _typebox.Type.Object({
+      amount: _typebox.Type.BigInt()
+    });
+    const result = (0, _index.parseArgvWithSchema)({
+      amount: "999"
+    }, s);
+    (0, _bunTest.expect)(result.amount).toBe(BigInt(999));
+  });
+  (0, _bunTest.test)("coerces array field from single string value", () => {
+    const s = _typebox.Type.Object({
+      tags: _typebox.Type.Array(_typebox.Type.String())
+    });
+    const result = (0, _index.parseArgvWithSchema)({
+      tags: "alpha"
+    }, s);
+    (0, _bunTest.expect)(result.tags).toEqual(["alpha"]);
+  });
+  (0, _bunTest.test)("passes through already-array value", () => {
+    const s = _typebox.Type.Object({
+      ids: _typebox.Type.Array(_typebox.Type.String())
+    });
+    const result = (0, _index.parseArgvWithSchema)({
+      ids: ["a", "b"]
+    }, s);
+    (0, _bunTest.expect)(result.ids).toEqual(["a", "b"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// generateActionHelp
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("generateActionHelp", () => {
+  const action = {
+    name: "send-tx",
+    description: "Send a transaction",
+    inputSchema: _typebox.Type.Object({
+      recipient: _typebox.Type.String({
+        description: "Target address"
+      }),
+      amount: _typebox.Type.Integer(),
+      memo: _typebox.Type.Optional(_typebox.Type.String({
+        default: ""
+      }))
+    }),
+    outputSchema: _typebox.Type.Object({
+      txId: _typebox.Type.String()
+    }),
+    execute: async () => ({
+      txId: "abc"
+    })
+  };
+  (0, _bunTest.test)("includes usage line with action name", () => {
+    const help = (0, _index.generateActionHelp)(action);
+    (0, _bunTest.expect)(help).toContain("Usage: app send-tx [options]");
+  });
+  (0, _bunTest.test)("uses custom appName in usage line when provided", () => {
+    const help = (0, _index.generateActionHelp)(action, "my-cli");
+    (0, _bunTest.expect)(help).toContain("Usage: my-cli send-tx [options]");
+  });
+  (0, _bunTest.test)("includes action description", () => {
+    const help = (0, _index.generateActionHelp)(action);
+    (0, _bunTest.expect)(help).toContain("Send a transaction");
+  });
+  (0, _bunTest.test)("lists required field as --flag-name with required label", () => {
+    const help = (0, _index.generateActionHelp)(action);
+    (0, _bunTest.expect)(help).toContain("--recipient");
+    (0, _bunTest.expect)(help).toContain("(required)");
+  });
+  (0, _bunTest.test)("lists optional field with optional label", () => {
+    const help = (0, _index.generateActionHelp)(action);
+    (0, _bunTest.expect)(help).toContain("--memo");
+    (0, _bunTest.expect)(help).toContain("(optional)");
+  });
+  (0, _bunTest.test)("converts camelCase property names to kebab-case flags", () => {
+    const a = {
+      ...action,
+      inputSchema: _typebox.Type.Object({
+        myValue: _typebox.Type.String()
+      })
+    };
+    const help = (0, _index.generateActionHelp)(a);
+    (0, _bunTest.expect)(help).toContain("--my-value");
+  });
+  (0, _bunTest.test)("includes type labels for each flag", () => {
+    const help = (0, _index.generateActionHelp)(action);
+    (0, _bunTest.expect)(help).toContain("<string>");
+    (0, _bunTest.expect)(help).toContain("<integer>");
+  });
+  (0, _bunTest.test)("includes --help at the end", () => {
+    const help = (0, _index.generateActionHelp)(action);
+    (0, _bunTest.expect)(help).toContain("--help");
+  });
+  (0, _bunTest.test)("shows field description when provided", () => {
+    const help = (0, _index.generateActionHelp)(action);
+    (0, _bunTest.expect)(help).toContain("Target address");
+  });
+  (0, _bunTest.test)("includes BigInt type label", () => {
+    const a = {
+      ...action,
+      inputSchema: _typebox.Type.Object({
+        amount: _typebox.Type.BigInt()
+      })
+    };
+    (0, _bunTest.expect)((0, _index.generateActionHelp)(a)).toContain("<bigint>");
+  });
+  (0, _bunTest.test)("includes boolean type label", () => {
+    const a = {
+      ...action,
+      inputSchema: _typebox.Type.Object({
+        dryRun: _typebox.Type.Boolean()
+      })
+    };
+    (0, _bunTest.expect)((0, _index.generateActionHelp)(a)).toContain("<boolean>");
+  });
+  (0, _bunTest.test)("array type label mentions repeatable", () => {
+    const a = {
+      ...action,
+      inputSchema: _typebox.Type.Object({
+        tags: _typebox.Type.Array(_typebox.Type.String())
+      })
+    };
+    (0, _bunTest.expect)((0, _index.generateActionHelp)(a)).toContain("repeatable");
+  });
+  (0, _bunTest.test)("object type label shows <json>", () => {
+    const a = {
+      ...action,
+      inputSchema: _typebox.Type.Object({
+        opts: _typebox.Type.Object({
+          x: _typebox.Type.String()
+        })
+      })
+    };
+    (0, _bunTest.expect)((0, _index.generateActionHelp)(a)).toContain("<json>");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// generateAppHelp
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("generateAppHelp", () => {
+  const actions = [{
+    name: "send-tx",
+    description: "Send a transaction",
+    category: "wallet",
+    inputSchema: _typebox.Type.Object({}),
+    outputSchema: _typebox.Type.Object({}),
+    execute: async () => ({})
+  }, {
+    name: "get-balance",
+    description: "Get balance",
+    category: "wallet",
+    inputSchema: _typebox.Type.Object({}),
+    outputSchema: _typebox.Type.Object({}),
+    execute: async () => ({})
+  }, {
+    name: "list-pools",
+    description: "List pools",
+    inputSchema: _typebox.Type.Object({}),
+    outputSchema: _typebox.Type.Object({}),
+    execute: async () => ({})
+  }];
+  (0, _bunTest.test)("includes usage line with app name", () => {
+    const help = (0, _index.generateAppHelp)(actions);
+    (0, _bunTest.expect)(help).toContain("Usage: app <action> [options]");
+  });
+  (0, _bunTest.test)("uses custom appName in usage line", () => {
+    const help = (0, _index.generateAppHelp)(actions, "my-app");
+    (0, _bunTest.expect)(help).toContain("Usage: my-app <action> [options]");
+  });
+  (0, _bunTest.test)("lists all action names", () => {
+    const help = (0, _index.generateAppHelp)(actions);
+    (0, _bunTest.expect)(help).toContain("send-tx");
+    (0, _bunTest.expect)(help).toContain("get-balance");
+    (0, _bunTest.expect)(help).toContain("list-pools");
+  });
+  (0, _bunTest.test)("lists all action descriptions", () => {
+    const help = (0, _index.generateAppHelp)(actions);
+    (0, _bunTest.expect)(help).toContain("Send a transaction");
+    (0, _bunTest.expect)(help).toContain("Get balance");
+    (0, _bunTest.expect)(help).toContain("List pools");
+  });
+  (0, _bunTest.test)("includes global options section", () => {
+    const help = (0, _index.generateAppHelp)(actions);
+    (0, _bunTest.expect)(help).toContain("Global options:");
+    (0, _bunTest.expect)(help).toContain("--help");
+    (0, _bunTest.expect)(help).toContain("--profile");
+  });
+  (0, _bunTest.test)("groups categorized actions under category heading", () => {
+    const help = (0, _index.generateAppHelp)(actions);
+    (0, _bunTest.expect)(help).toContain("wallet:");
+  });
+  (0, _bunTest.test)("shows 'No actions registered.' for empty actions list", () => {
+    const help = (0, _index.generateAppHelp)([]);
+    (0, _bunTest.expect)(help).toContain("No actions registered.");
+  });
+  (0, _bunTest.test)("does not show a category heading for 'default' category", () => {
+    const uncategorized = [{
+      name: "do-thing",
+      description: "Does a thing",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => ({})
+    }];
+    const help = (0, _index.generateAppHelp)(uncategorized);
+    (0, _bunTest.expect)(help).not.toContain("default:");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runCli
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("runCli", () => {
+  let logSpy;
+  let errorSpy;
+  let exitSpy;
+  const echoAction = {
+    name: "echo",
+    description: "Echoes input",
+    inputSchema: _typebox.Type.Object({
+      message: _typebox.Type.String()
+    }),
+    outputSchema: _typebox.Type.Object({
+      message: _typebox.Type.String()
+    }),
+    execute: async input => ({
+      message: input.message
+    })
+  };
+  (0, _bunTest.beforeEach)(() => {
+    logSpy = (0, _bunTest.spyOn)(console, "log").mockImplementation(() => {});
+    errorSpy = (0, _bunTest.spyOn)(console, "error").mockImplementation(() => {});
+    exitSpy = (0, _bunTest.spyOn)(process, "exit").mockImplementation(() => {});
+  });
+  (0, _bunTest.afterEach)(() => {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  // Success path
+  (0, _bunTest.test)("logs JSON success output to stdout on valid input", async () => {
+    const sprinkle = makeMockSprinkle([echoAction]);
+    await (0, _index.runCli)(sprinkle, "echo", {
+      message: "hello"
+    }, fakeContext);
+    (0, _bunTest.expect)(logSpy).toHaveBeenCalledTimes(1);
+    const output = JSON.parse(String(logSpy.mock.calls[0][0]));
+    (0, _bunTest.expect)(output.success).toBe(true);
+    (0, _bunTest.expect)(output.data).toEqual({
+      message: "hello"
+    });
+  });
+  (0, _bunTest.test)("does not call process.exit on success", async () => {
+    const sprinkle = makeMockSprinkle([echoAction]);
+    await (0, _index.runCli)(sprinkle, "echo", {
+      message: "hi"
+    }, fakeContext);
+    (0, _bunTest.expect)(exitSpy).not.toHaveBeenCalled();
+  });
+
+  // Failure path: action not found
+  // Note: process.exit() is mocked to throw a sentinel error so that execution
+  // does not continue past the exit call (matching real runtime behaviour).
+  (0, _bunTest.test)("logs JSON error to stderr when action not found", async () => {
+    exitSpy.mockImplementation(() => {
+      throw new Error("process.exit called");
+    });
+    const sprinkle = makeMockSprinkle([]);
+    await (0, _bunTest.expect)((0, _index.runCli)(sprinkle, "unknown-action", {}, fakeContext)).rejects.toThrow("process.exit called");
+    (0, _bunTest.expect)(errorSpy).toHaveBeenCalledTimes(1);
+    const output = JSON.parse(String(errorSpy.mock.calls[0][0]));
+    (0, _bunTest.expect)(output.success).toBe(false);
+    (0, _bunTest.expect)(output.error.code).toBe("ACTION_NOT_FOUND");
+  });
+  (0, _bunTest.test)("calls process.exit(1) when action not found", async () => {
+    exitSpy.mockImplementation(() => {
+      throw new Error("process.exit called");
+    });
+    const sprinkle = makeMockSprinkle([]);
+    await (0, _bunTest.expect)((0, _index.runCli)(sprinkle, "ghost", {}, fakeContext)).rejects.toThrow("process.exit called");
+    (0, _bunTest.expect)(exitSpy).toHaveBeenCalledWith(1);
+  });
+  (0, _bunTest.test)("error message lists available actions when action not found", async () => {
+    exitSpy.mockImplementation(() => {
+      throw new Error("process.exit called");
+    });
+    const sprinkle = makeMockSprinkle([echoAction]);
+    await (0, _bunTest.expect)((0, _index.runCli)(sprinkle, "nope", {}, fakeContext)).rejects.toThrow("process.exit called");
+    const output = JSON.parse(String(errorSpy.mock.calls[0][0]));
+    (0, _bunTest.expect)(output.error.message).toContain("echo");
+  });
+  (0, _bunTest.test)("error message shows (none) when no actions registered", async () => {
+    exitSpy.mockImplementation(() => {
+      throw new Error("process.exit called");
+    });
+    const sprinkle = makeMockSprinkle([]);
+    await (0, _bunTest.expect)((0, _index.runCli)(sprinkle, "ghost", {}, fakeContext)).rejects.toThrow("process.exit called");
+    const output = JSON.parse(String(errorSpy.mock.calls[0][0]));
+    (0, _bunTest.expect)(output.error.message).toContain("(none)");
+  });
+
+  // Failure path: validation error
+  (0, _bunTest.test)("logs JSON error to stderr and exits on validation failure", async () => {
+    const sprinkle = makeMockSprinkle([echoAction]);
+    // Missing required 'message' field
+    await (0, _index.runCli)(sprinkle, "echo", {}, fakeContext);
+    (0, _bunTest.expect)(errorSpy).toHaveBeenCalledTimes(1);
+    const output = JSON.parse(String(errorSpy.mock.calls[0][0]));
+    (0, _bunTest.expect)(output.success).toBe(false);
+    (0, _bunTest.expect)(output.error.code).toBe("VALIDATION_ERROR");
+    (0, _bunTest.expect)(exitSpy).toHaveBeenCalledWith(1);
+  });
+  (0, _bunTest.test)("does not write to stdout on validation failure", async () => {
+    const sprinkle = makeMockSprinkle([echoAction]);
+    await (0, _index.runCli)(sprinkle, "echo", {}, fakeContext);
+    (0, _bunTest.expect)(logSpy).not.toHaveBeenCalled();
+  });
+
+  // Help flag
+  (0, _bunTest.test)("prints action help to stdout when --help is in rawArgs", async () => {
+    const sprinkle = makeMockSprinkle([echoAction]);
+    await (0, _index.runCli)(sprinkle, "echo", {
+      help: true
+    }, fakeContext);
+    (0, _bunTest.expect)(logSpy).toHaveBeenCalledTimes(1);
+    const output = String(logSpy.mock.calls[0][0]);
+    (0, _bunTest.expect)(output).toContain("Usage:");
+    (0, _bunTest.expect)(output).toContain("echo");
+  });
+  (0, _bunTest.test)("does not exit when --help flag is set", async () => {
+    const sprinkle = makeMockSprinkle([echoAction]);
+    await (0, _index.runCli)(sprinkle, "echo", {
+      help: true
+    }, fakeContext);
+    (0, _bunTest.expect)(exitSpy).not.toHaveBeenCalled();
+  });
+  (0, _bunTest.test)("does not call stderr when --help flag is set", async () => {
+    const sprinkle = makeMockSprinkle([echoAction]);
+    await (0, _index.runCli)(sprinkle, "echo", {
+      help: true
+    }, fakeContext);
+    (0, _bunTest.expect)(errorSpy).not.toHaveBeenCalled();
+  });
+
+  // BigInt in output
+  (0, _bunTest.test)("serializes BigInt values in output using bigIntReplacer", async () => {
+    const bigIntAction = {
+      name: "big-action",
+      description: "Returns a BigInt",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({
+        amount: _typebox.Type.BigInt()
+      }),
+      execute: async () => ({
+        amount: BigInt("9007199254740993")
+      })
+    };
+    const sprinkle = makeMockSprinkle([bigIntAction]);
+    await (0, _index.runCli)(sprinkle, "big-action", {}, fakeContext);
+    (0, _bunTest.expect)(logSpy).toHaveBeenCalledTimes(1);
+    const rawOutput = String(logSpy.mock.calls[0][0]);
+    // BigInt should appear as a string in JSON (bigIntReplacer converts it)
+    (0, _bunTest.expect)(rawOutput).toContain("9007199254740993");
+  });
+
+  // Custom appName in help
+  (0, _bunTest.test)("uses custom appName in action help output", async () => {
+    const sprinkle = makeMockSprinkle([echoAction]);
+    await (0, _index.runCli)(sprinkle, "echo", {
+      help: true
+    }, fakeContext, "my-cli");
+    const output = String(logSpy.mock.calls[0][0]);
+    (0, _bunTest.expect)(output).toContain("my-cli");
+  });
+
+  // Execution error from action
+  (0, _bunTest.test)("logs JSON error to stderr when action execute throws", async () => {
+    const failAction = {
+      name: "fail-action",
+      description: "Always fails",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => {
+        throw new Error("something broke");
+      }
+    };
+    const sprinkle = makeMockSprinkle([failAction]);
+    await (0, _index.runCli)(sprinkle, "fail-action", {}, fakeContext);
+    (0, _bunTest.expect)(errorSpy).toHaveBeenCalledTimes(1);
+    const output = JSON.parse(String(errorSpy.mock.calls[0][0]));
+    (0, _bunTest.expect)(output.success).toBe(false);
+    (0, _bunTest.expect)(output.error.code).toBe("EXECUTION_ERROR");
+    (0, _bunTest.expect)(output.error.message).toContain("something broke");
+    (0, _bunTest.expect)(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  // Schema-driven coercion through runCli
+  (0, _bunTest.test)("coerces string args to correct types via schema before execution", async () => {
+    let captured;
+    const intAction = {
+      name: "int-action",
+      description: "Takes an integer",
+      inputSchema: _typebox.Type.Object({
+        count: _typebox.Type.Integer()
+      }),
+      outputSchema: _typebox.Type.Object({
+        count: _typebox.Type.Integer()
+      }),
+      execute: async input => {
+        captured = input;
+        return input;
+      }
+    };
+    const sprinkle = makeMockSprinkle([intAction]);
+    await (0, _index.runCli)(sprinkle, "int-action", {
+      count: "7"
+    }, fakeContext);
+    (0, _bunTest.expect)(captured.count).toBe(7);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseCliArgs repeated flag support (tested via action-runner, but verifying
+// that the repeated-flag array output integrates with coerceValue)
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("coerceValue with repeated flag arrays", () => {
+  (0, _bunTest.test)("passes already-array through Array schema and coerces each item", () => {
+    // Simulates what parseCliArgs produces for --tag a --tag b
+    const raw = ["a", "b", "c"];
+    const result = (0, _index.coerceValue)(raw, _typebox.Type.Array(_typebox.Type.String()));
+    (0, _bunTest.expect)(result).toEqual(["a", "b", "c"]);
+  });
+  (0, _bunTest.test)("coerces repeated numeric string flags to integer array", () => {
+    const raw = ["1", "2", "3"];
+    const result = (0, _index.coerceValue)(raw, _typebox.Type.Array(_typebox.Type.Integer()));
+    (0, _bunTest.expect)(result).toEqual([1, 2, 3]);
+  });
+});
+//# sourceMappingURL=cli-adapter.test.js.map