@enactprotocol/shared 1.2.13 → 2.0.1

package/tests/execution/command.test.ts

@@ -0,0 +1,317 @@
+/**
+ * Tests for command interpolation module
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  getMissingParams,
+  interpolateCommand,
+  parseCommand,
+  parseCommandArgs,
+  prepareCommand,
+  shellEscape,
+} from "../../src/execution/command";
+
+describe("Command Interpolation", () => {
+  describe("parseCommand", () => {
+    test("parses command with no parameters", () => {
+      const result = parseCommand("echo hello");
+
+      expect(result.original).toBe("echo hello");
+      expect(result.tokens).toHaveLength(1);
+      expect(result.tokens[0]).toEqual({ type: "literal", value: "echo hello" });
+      expect(result.parameters).toHaveLength(0);
+    });
+
+    test("parses command with single parameter", () => {
+      const result = parseCommand("echo ${message}");
+
+      expect(result.original).toBe("echo ${message}");
+      expect(result.tokens).toHaveLength(2);
+      expect(result.tokens[0]).toEqual({ type: "literal", value: "echo " });
+      expect(result.tokens[1]).toEqual({ type: "parameter", name: "message" });
+      expect(result.parameters).toEqual(["message"]);
+    });
+
+    test("parses command with multiple parameters", () => {
+      const result = parseCommand("curl -X ${method} ${url} -d '${data}'");
+
+      expect(result.parameters).toContain("method");
+      expect(result.parameters).toContain("url");
+      expect(result.parameters).toContain("data");
+      expect(result.parameters).toHaveLength(3);
+    });
+
+    test("parses command with parameter at start", () => {
+      const result = parseCommand("${cmd} arg1 arg2");
+
+      expect(result.tokens[0]).toEqual({ type: "parameter", name: "cmd" });
+      expect(result.tokens[1]).toEqual({ type: "literal", value: " arg1 arg2" });
+    });
+
+    test("parses command with adjacent parameters", () => {
+      const result = parseCommand("${prefix}${suffix}");
+
+      expect(result.tokens).toHaveLength(2);
+      expect(result.tokens[0]).toEqual({ type: "parameter", name: "prefix" });
+      expect(result.tokens[1]).toEqual({ type: "parameter", name: "suffix" });
+    });
+
+    test("handles nested braces", () => {
+      const result = parseCommand("echo '${json}' | jq '.${field}'");
+
+      expect(result.parameters).toContain("json");
+      expect(result.parameters).toContain("field");
+    });
+
+    test("removes duplicate parameters", () => {
+      const result = parseCommand("echo ${name} ${name} ${name}");
+
+      expect(result.parameters).toEqual(["name"]);
+    });
+  });
+
+  describe("interpolateCommand", () => {
+    test("interpolates single parameter", () => {
+      // By default, escape=true, so values get shell-escaped
+      const result = interpolateCommand("echo ${message}", {
+        message: "hello world",
+      });
+
+      // "hello world" contains space, gets single-quoted
+      expect(result).toBe("echo 'hello world'");
+    });
+
+    test("interpolates multiple parameters", () => {
+      const result = interpolateCommand("curl -X ${method} ${url}", {
+        method: "POST",
+        url: "https://api.example.com",
+      });
+
+      // URL contains special chars, gets quoted
+      expect(result).toBe("curl -X POST 'https://api.example.com'");
+    });
+
+    test("handles missing parameters with keep option", () => {
+      const result = interpolateCommand("echo ${message}", {}, { onMissing: "keep" });
+
+      // Missing params are left as-is when onMissing is "keep"
+      expect(result).toBe("echo ${message}");
+    });
+
+    test("throws on missing parameters by default", () => {
+      expect(() => interpolateCommand("echo ${message}", {})).toThrow(
+        "Missing required parameter: message"
+      );
+    });
+
+    test("converts numbers to strings", () => {
+      const result = interpolateCommand("seq ${start} ${end}", {
+        start: 1,
+        end: 10,
+      });
+
+      expect(result).toBe("seq 1 10");
+    });
+
+    test("handles boolean values", () => {
+      const result = interpolateCommand("echo ${flag}", {
+        flag: true,
+      });
+
+      expect(result).toBe("echo true");
+    });
+
+    test("handles null values as empty string", () => {
+      const result = interpolateCommand("echo ${a}", {
+        a: null,
+      });
+
+      // null becomes empty string
+      expect(result).toBe("echo ''");
+    });
+
+    test("stringifies objects as JSON", () => {
+      const result = interpolateCommand(
+        "echo ${data}",
+        {
+          data: { key: "value" },
+        },
+        { escape: false }
+      );
+
+      expect(result).toBe('echo {"key":"value"}');
+    });
+
+    test("handles arrays", () => {
+      const result = interpolateCommand(
+        "echo ${items}",
+        {
+          items: [1, 2, 3],
+        },
+        { escape: false }
+      );
+
+      expect(result).toBe("echo [1,2,3]");
+    });
+  });
+
+  describe("shellEscape", () => {
+    test("escapes single quotes", () => {
+      // The implementation uses: 'it'"'"'s' pattern
+      expect(shellEscape("it's")).toBe("'it'\"'\"'s'");
+    });
+
+    test("wraps strings with spaces", () => {
+      expect(shellEscape("hello world")).toBe("'hello world'");
+    });
+
+    test("escapes special characters", () => {
+      expect(shellEscape("test$var")).toBe("'test$var'");
+      expect(shellEscape("test`cmd`")).toBe("'test`cmd`'");
+    });
+
+    test("returns safe strings as-is", () => {
+      expect(shellEscape("simple")).toBe("simple");
+      expect(shellEscape("path/to/file")).toBe("path/to/file");
+      expect(shellEscape("file.txt")).toBe("file.txt");
+    });
+
+    test("handles empty string", () => {
+      expect(shellEscape("")).toBe("''");
+    });
+
+    test("handles strings with newlines", () => {
+      expect(shellEscape("line1\nline2")).toBe("'line1\nline2'");
+    });
+
+    test("handles strings with backslashes", () => {
+      expect(shellEscape("path\\to\\file")).toBe("'path\\to\\file'");
+    });
+  });
+
+  describe("parseCommandArgs", () => {
+    test("parses simple arguments", () => {
+      const result = parseCommandArgs("arg1 arg2 arg3");
+
+      expect(result).toEqual(["arg1", "arg2", "arg3"]);
+    });
+
+    test("handles quoted strings", () => {
+      const result = parseCommandArgs('echo "hello world"');
+
+      expect(result).toEqual(["echo", "hello world"]);
+    });
+
+    test("handles single-quoted strings", () => {
+      const result = parseCommandArgs("echo 'hello world'");
+
+      expect(result).toEqual(["echo", "hello world"]);
+    });
+
+    test("handles mixed quotes", () => {
+      const result = parseCommandArgs("echo 'single' \"double\"");
+
+      expect(result).toEqual(["echo", "single", "double"]);
+    });
+
+    test("handles empty input", () => {
+      expect(parseCommandArgs("")).toEqual([]);
+    });
+
+    test("handles extra whitespace", () => {
+      const result = parseCommandArgs("  arg1   arg2   ");
+
+      expect(result).toEqual(["arg1", "arg2"]);
+    });
+
+    test("handles escaped quotes within strings", () => {
+      const result = parseCommandArgs('echo "say \\"hello\\""');
+
+      expect(result).toEqual(["echo", 'say "hello"']);
+    });
+  });
+
+  describe("prepareCommand", () => {
+    test("prepares simple command without shell wrap", () => {
+      const result = prepareCommand("echo hello", {});
+
+      expect(result).toEqual(["echo", "hello"]);
+    });
+
+    test("wraps command with pipes", () => {
+      const result = prepareCommand("echo hello | cat", {});
+
+      // Contains | which triggers shell wrap
+      expect(result).toEqual(["sh", "-c", "echo hello | cat"]);
+    });
+
+    test("interpolates parameters without shell wrap when no special chars", () => {
+      // After interpolation, "echo world" has no special chars
+      const result = prepareCommand("echo ${name}", { name: "world" });
+
+      expect(result).toEqual(["echo", "world"]);
+    });
+
+    test("handles commands with pipes", () => {
+      const result = prepareCommand("cat file | grep pattern", {});
+
+      expect(result).toEqual(["sh", "-c", "cat file | grep pattern"]);
+    });
+
+    test("parses simple args without shell features", () => {
+      // No special chars, so should parse as args
+      const result = prepareCommand("simple command here", {});
+
+      expect(result).toEqual(["simple", "command", "here"]);
+    });
+
+    test("shell wraps when escaped value contains quotes", () => {
+      // When value has spaces, it gets single-quoted, but parseCommandArgs
+      // handles quotes properly, so it still gets parsed as args
+      const result = prepareCommand("echo ${msg}", { msg: "hello world" });
+
+      // parseCommandArgs strips the quotes, so we get the unquoted value
+      expect(result).toEqual(["echo", "hello world"]);
+    });
+  });
+
+  describe("getMissingParams", () => {
+    test("returns empty array when all params present", () => {
+      const result = getMissingParams("echo ${a} ${b}", { a: "1", b: "2" });
+
+      expect(result).toEqual([]);
+    });
+
+    test("returns missing param names", () => {
+      const result = getMissingParams("echo ${a} ${b} ${c}", { a: "1" });
+
+      expect(result).toContain("b");
+      expect(result).toContain("c");
+      expect(result).not.toContain("a");
+    });
+
+    test("handles no parameters", () => {
+      const result = getMissingParams("echo hello", {});
+
+      expect(result).toEqual([]);
+    });
+
+    test("handles all parameters missing", () => {
+      const result = getMissingParams("echo ${x} ${y}", {});
+
+      expect(result).toEqual(["x", "y"]);
+    });
+
+    test("treats null as present but undefined as missing", () => {
+      // null is a value (present), undefined means not provided
+      const result = getMissingParams("echo ${a} ${b}", {
+        a: null,
+        b: undefined,
+      });
+
+      // Only b is missing since undefined is treated as not provided
+      expect(result).toEqual(["b"]);
+    });
+  });
+});

package/tests/execution/validation.test.ts

@@ -0,0 +1,384 @@
+/**
+ * Tests for input validation module
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { JSONSchema7 } from "json-schema";
+import {
+  applyDefaults,
+  getParamInfo,
+  getRequiredParams,
+  validateInputs,
+} from "../../src/execution/validation";
+
+describe("Input Validation", () => {
+  describe("validateInputs", () => {
+    const simpleSchema: JSONSchema7 = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        count: { type: "number" },
+      },
+      required: ["name"],
+    };
+
+    test("validates correct inputs", () => {
+      const result = validateInputs({ name: "test", count: 5 }, simpleSchema);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test("reports missing required fields", () => {
+      const result = validateInputs({ count: 5 }, simpleSchema);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0]?.path).toContain("name");
+    });
+
+    test("reports type errors", () => {
+      const result = validateInputs({ name: "test", count: "not a number" }, simpleSchema);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.path.includes("count"))).toBe(true);
+    });
+
+    test("validates nested objects", () => {
+      const nestedSchema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          config: {
+            type: "object",
+            properties: {
+              timeout: { type: "number" },
+            },
+            required: ["timeout"],
+          },
+        },
+        required: ["config"],
+      };
+
+      const result = validateInputs({ config: { timeout: 30 } }, nestedSchema);
+
+      expect(result.valid).toBe(true);
+    });
+
+    test("validates arrays", () => {
+      const arraySchema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          items: {
+            type: "array",
+            items: { type: "string" },
+          },
+        },
+      };
+
+      const result = validateInputs({ items: ["a", "b", "c"] }, arraySchema);
+
+      expect(result.valid).toBe(true);
+    });
+
+    test("handles empty inputs", () => {
+      const result = validateInputs({}, simpleSchema);
+
+      // Missing required "name"
+      expect(result.valid).toBe(false);
+    });
+
+    test("validates string patterns", () => {
+      const patternSchema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          email: {
+            type: "string",
+            pattern: "^[a-z]+@[a-z]+\\.[a-z]+$",
+          },
+        },
+      };
+
+      const validResult = validateInputs({ email: "test@example.com" }, patternSchema);
+      expect(validResult.valid).toBe(true);
+
+      const invalidResult = validateInputs({ email: "not-an-email" }, patternSchema);
+      expect(invalidResult.valid).toBe(false);
+    });
+
+    test("validates enums", () => {
+      const enumSchema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            enum: ["active", "inactive", "pending"],
+          },
+        },
+      };
+
+      const validResult = validateInputs({ status: "active" }, enumSchema);
+      expect(validResult.valid).toBe(true);
+
+      const invalidResult = validateInputs({ status: "unknown" }, enumSchema);
+      expect(invalidResult.valid).toBe(false);
+    });
+
+    test("validates minimum and maximum", () => {
+      const rangeSchema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          count: { type: "number", minimum: 0, maximum: 100 },
+        },
+      };
+
+      expect(validateInputs({ count: 50 }, rangeSchema).valid).toBe(true);
+      expect(validateInputs({ count: -1 }, rangeSchema).valid).toBe(false);
+      expect(validateInputs({ count: 101 }, rangeSchema).valid).toBe(false);
+    });
+
+    test("validates string lengths", () => {
+      const lengthSchema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          name: { type: "string", minLength: 2, maxLength: 10 },
+        },
+      };
+
+      expect(validateInputs({ name: "test" }, lengthSchema).valid).toBe(true);
+      expect(validateInputs({ name: "x" }, lengthSchema).valid).toBe(false);
+      expect(validateInputs({ name: "this is too long" }, lengthSchema).valid).toBe(false);
+    });
+  });
+
+  describe("applyDefaults", () => {
+    test("applies default values", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          name: { type: "string", default: "default_name" },
+          count: { type: "number", default: 10 },
+        },
+      };
+
+      const result = applyDefaults({}, schema);
+
+      expect(result.name).toBe("default_name");
+      expect(result.count).toBe(10);
+    });
+
+    test("preserves provided values", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          name: { type: "string", default: "default_name" },
+        },
+      };
+
+      const result = applyDefaults({ name: "custom_name" }, schema);
+
+      expect(result.name).toBe("custom_name");
+    });
+
+    test("applies nested defaults", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          config: {
+            type: "object",
+            default: { timeout: 30, retries: 3 },
+          },
+        },
+      };
+
+      const result = applyDefaults({}, schema);
+
+      expect(result.config).toEqual({ timeout: 30, retries: 3 });
+    });
+
+    test("handles array defaults", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          tags: {
+            type: "array",
+            default: ["default", "tag"],
+          },
+        },
+      };
+
+      const result = applyDefaults({}, schema);
+
+      expect(result.tags).toEqual(["default", "tag"]);
+    });
+
+    test("handles boolean defaults", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          enabled: { type: "boolean", default: true },
+        },
+      };
+
+      const result = applyDefaults({}, schema);
+
+      expect(result.enabled).toBe(true);
+    });
+
+    test("does not apply defaults for explicit null", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          value: { type: "string", default: "default" },
+        },
+      };
+
+      // Explicitly passing null should not trigger default
+      const result = applyDefaults({ value: null }, schema);
+
+      expect(result.value).toBeNull();
+    });
+
+    test("applies defaults only for undefined", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          value: { type: "string", default: "default" },
+          count: { type: "number", default: 0 },
+        },
+      };
+
+      const result = applyDefaults({ value: undefined }, schema);
+
+      expect(result.value).toBe("default");
+      expect(result.count).toBe(0);
+    });
+  });
+
+  describe("getRequiredParams", () => {
+    test("returns required parameter names", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          email: { type: "string" },
+          age: { type: "number" },
+        },
+        required: ["name", "email"],
+      };
+
+      const result = getRequiredParams(schema);
+
+      expect(result).toContain("name");
+      expect(result).toContain("email");
+      expect(result).not.toContain("age");
+    });
+
+    test("returns empty array when no required params", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+        },
+      };
+
+      const result = getRequiredParams(schema);
+
+      expect(result).toEqual([]);
+    });
+
+    test("handles schema without properties", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+      };
+
+      const result = getRequiredParams(schema);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("getParamInfo", () => {
+    test("extracts parameter information", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: "User name",
+            default: "anonymous",
+          },
+          count: {
+            type: "number",
+            description: "Item count",
+            minimum: 0,
+          },
+        },
+        required: ["name"],
+      };
+
+      const result = getParamInfo(schema);
+
+      expect(result.size).toBe(2);
+
+      const nameParam = result.get("name");
+      expect(nameParam).toBeDefined();
+      expect(nameParam?.type).toBe("string");
+      expect(nameParam?.description).toBe("User name");
+      expect(nameParam?.required).toBe(true);
+      expect(nameParam?.default).toBe("anonymous");
+
+      const countParam = result.get("count");
+      expect(countParam).toBeDefined();
+      expect(countParam?.type).toBe("number");
+      expect(countParam?.required).toBe(false);
+    });
+
+    test("handles array types", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tags for categorization",
+          },
+        },
+      };
+
+      const result = getParamInfo(schema);
+      const tagsParam = result.get("tags");
+
+      expect(tagsParam?.type).toBe("array");
+    });
+
+    test("handles enum types", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            enum: ["active", "inactive"],
+            description: "Account status",
+          },
+        },
+      };
+
+      const result = getParamInfo(schema);
+      const statusParam = result.get("status");
+
+      // Note: getParamInfo doesn't extract enum values, just type
+      expect(statusParam).toBeDefined();
+      expect(statusParam?.type).toBe("string");
+    });
+
+    test("returns empty Map for schema without properties", () => {
+      const schema: JSONSchema7 = {
+        type: "object",
+      };
+
+      const result = getParamInfo(schema);
+
+      expect(result.size).toBe(0);
+    });
+  });
+});

package/tests/fixtures/invalid-tool.yaml

@@ -0,0 +1,4 @@
+# Missing required fields
+version: "1.0.0"
+# name is missing
+# description is missing