@enactprotocol/cli 1.2.13 → 2.0.0

package/tests/commands/list.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Tests for the list command
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { Command } from "commander";
+import { configureListCommand } from "../../src/commands/list";
+
+// Test fixtures directory
+const FIXTURES_DIR = join(import.meta.dir, "..", "fixtures", "list-cmd");
+
+describe("list command", () => {
+  beforeAll(() => {
+    mkdirSync(FIXTURES_DIR, { recursive: true });
+  });
+
+  beforeEach(() => {
+    if (existsSync(FIXTURES_DIR)) {
+      rmSync(FIXTURES_DIR, { recursive: true, force: true });
+      mkdirSync(FIXTURES_DIR, { recursive: true });
+    }
+  });
+
+  afterAll(() => {
+    if (existsSync(FIXTURES_DIR)) {
+      rmSync(FIXTURES_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("command configuration", () => {
+    test("configures list command on program", () => {
+      const program = new Command();
+      configureListCommand(program);
+
+      const listCmd = program.commands.find((cmd) => cmd.name() === "list");
+      expect(listCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configureListCommand(program);
+
+      const listCmd = program.commands.find((cmd) => cmd.name() === "list");
+      expect(listCmd?.description()).toBe("List installed tools");
+    });
+
+    test("has 'ls' as alias", () => {
+      const program = new Command();
+      configureListCommand(program);
+
+      const listCmd = program.commands.find((cmd) => cmd.name() === "list");
+      const aliases = listCmd?.aliases() ?? [];
+      expect(aliases).toContain("ls");
+    });
+
+    test("has --global option", () => {
+      const program = new Command();
+      configureListCommand(program);
+
+      const listCmd = program.commands.find((cmd) => cmd.name() === "list");
+      const opts = listCmd?.options ?? [];
+      const globalOpt = opts.find((o) => o.long === "--global");
+      expect(globalOpt).toBeDefined();
+    });
+
+    test("has --verbose option", () => {
+      const program = new Command();
+      configureListCommand(program);
+
+      const listCmd = program.commands.find((cmd) => cmd.name() === "list");
+      const opts = listCmd?.options ?? [];
+      const verboseOpt = opts.find((o) => o.long === "--verbose");
+      expect(verboseOpt).toBeDefined();
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configureListCommand(program);
+
+      const listCmd = program.commands.find((cmd) => cmd.name() === "list");
+      const opts = listCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+  });
+
+  describe("scope filtering logic", () => {
+    test("default shows project and user tools", () => {
+      const options: { project?: boolean; user?: boolean; cache?: boolean; all?: boolean } = {};
+      const showProject = options.project || options.all || (!options.user && !options.cache);
+      const showUser = options.user || options.all || (!options.project && !options.cache);
+      const showCache = options.cache || options.all || false;
+
+      expect(showProject).toBe(true);
+      expect(showUser).toBe(true);
+      expect(showCache).toBe(false);
+    });
+
+    test("--project shows only project tools", () => {
+      const options = { project: true };
+      const showProject = options.project || false;
+      const showUser = !options.project && false;
+      const showCache = false;
+
+      expect(showProject).toBe(true);
+      expect(showUser).toBe(false);
+      expect(showCache).toBe(false);
+    });
+
+    test("--user shows only user tools", () => {
+      const options = { user: true };
+      expect(options.user).toBe(true);
+    });
+
+    test("--cache shows only cached tools", () => {
+      const options = { cache: true };
+      expect(options.cache).toBe(true);
+    });
+
+    test("--all shows all locations", () => {
+      const options = { all: true };
+      const showProject = options.all;
+      const showUser = options.all;
+      const showCache = options.all;
+
+      expect(showProject).toBe(true);
+      expect(showUser).toBe(true);
+      expect(showCache).toBe(true);
+    });
+  });
+
+  describe("tool info structure", () => {
+    test("tool info has required properties", () => {
+      const toolInfo = {
+        name: "alice/utils/greeter",
+        version: "1.0.0",
+        location: "/path/to/tool",
+        scope: "project",
+      };
+
+      expect(toolInfo.name).toBe("alice/utils/greeter");
+      expect(toolInfo.version).toBe("1.0.0");
+      expect(toolInfo.location).toBe("/path/to/tool");
+      expect(toolInfo.scope).toBe("project");
+    });
+
+    test("version defaults to dash for unversioned tools", () => {
+      const toolInfo = {
+        name: "alice/utils/greeter",
+        version: "-",
+        location: "/path/to/tool",
+        scope: "user",
+      };
+
+      expect(toolInfo.version).toBe("-");
+    });
+  });
+});

package/tests/commands/publish.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Tests for the publish command
+ */
+
+import { describe, expect, test } from "bun:test";
+import { Command } from "commander";
+import { configurePublishCommand } from "../../src/commands/publish";
+
+describe("publish command", () => {
+  describe("command configuration", () => {
+    test("configures publish command on program", () => {
+      const program = new Command();
+      configurePublishCommand(program);
+
+      const publishCmd = program.commands.find((cmd) => cmd.name() === "publish");
+      expect(publishCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configurePublishCommand(program);
+
+      const publishCmd = program.commands.find((cmd) => cmd.name() === "publish");
+      expect(publishCmd?.description()).toBe("Publish a tool to the Enact registry");
+    });
+
+    test("accepts optional file argument", () => {
+      const program = new Command();
+      configurePublishCommand(program);
+
+      const publishCmd = program.commands.find((cmd) => cmd.name() === "publish");
+      const args = publishCmd?.registeredArguments ?? [];
+      // Check there's an argument (file)
+      expect(args.length).toBeGreaterThanOrEqual(0);
+      // Could be optional, so may have no required args
+    });
+
+    test("has --dry-run option", () => {
+      const program = new Command();
+      configurePublishCommand(program);
+
+      const publishCmd = program.commands.find((cmd) => cmd.name() === "publish");
+      const opts = publishCmd?.options ?? [];
+      const dryRunOpt = opts.find((o) => o.long === "--dry-run");
+      expect(dryRunOpt).toBeDefined();
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configurePublishCommand(program);
+
+      const publishCmd = program.commands.find((cmd) => cmd.name() === "publish");
+      const opts = publishCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+  });
+
+  describe("manifest file detection", () => {
+    test("identifies enact.yaml as manifest", () => {
+      const isManifest = (filename: string): boolean => {
+        return filename === "enact.yaml" || filename === "enact.yml" || filename === "enact.md";
+      };
+
+      expect(isManifest("enact.yaml")).toBe(true);
+      expect(isManifest("enact.yml")).toBe(true);
+      expect(isManifest("enact.md")).toBe(true);
+      expect(isManifest("package.json")).toBe(false);
+    });
+
+    test("detects file extensions correctly", () => {
+      const getExtension = (filename: string): string => {
+        const lastDot = filename.lastIndexOf(".");
+        return lastDot === -1 ? "" : filename.slice(lastDot + 1);
+      };
+
+      expect(getExtension("enact.yaml")).toBe("yaml");
+      expect(getExtension("enact.yml")).toBe("yml");
+      expect(getExtension("enact.md")).toBe("md");
+      expect(getExtension("noextension")).toBe("");
+    });
+  });
+
+  describe("version validation", () => {
+    test("validates semver format", () => {
+      const isValidSemver = (version: string): boolean => {
+        const semverRegex = /^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?$/;
+        return semverRegex.test(version);
+      };
+
+      expect(isValidSemver("1.0.0")).toBe(true);
+      expect(isValidSemver("0.1.0")).toBe(true);
+      expect(isValidSemver("1.0.0-alpha")).toBe(true);
+      expect(isValidSemver("1.0.0-alpha.1")).toBe(true);
+      expect(isValidSemver("1.0.0+build")).toBe(true);
+      expect(isValidSemver("1.0")).toBe(false);
+      expect(isValidSemver("v1.0.0")).toBe(false);
+    });
+  });
+
+  describe("dry run behavior", () => {
+    test("dry run flag changes behavior", () => {
+      const shouldPublish = (dryRun: boolean): boolean => {
+        return !dryRun;
+      };
+
+      expect(shouldPublish(false)).toBe(true);
+      expect(shouldPublish(true)).toBe(false);
+    });
+  });
+
+  describe("bundle creation", () => {
+    test("bundle metadata structure", () => {
+      interface BundleMetadata {
+        name: string;
+        version: string;
+        hash: string;
+        size: number;
+        createdAt: string;
+      }
+
+      const metadata: BundleMetadata = {
+        name: "my-tool",
+        version: "1.0.0",
+        hash: "sha256:abc123",
+        size: 1024,
+        createdAt: new Date().toISOString(),
+      };
+
+      expect(metadata.name).toBe("my-tool");
+      expect(metadata.version).toBe("1.0.0");
+      expect(metadata.hash).toContain("sha256:");
+      expect(metadata.size).toBeGreaterThan(0);
+      expect(metadata.createdAt).toContain("T");
+    });
+
+    test("hash format validation", () => {
+      const isValidHash = (hash: string): boolean => {
+        return hash.startsWith("sha256:") && hash.length === 71; // sha256: + 64 hex chars
+      };
+
+      expect(isValidHash(`sha256:${"a".repeat(64)}`)).toBe(true);
+      expect(isValidHash(`sha512:${"a".repeat(128)}`)).toBe(false);
+      expect(isValidHash("invalid")).toBe(false);
+    });
+  });
+
+  describe("publish result handling", () => {
+    test("success result structure", () => {
+      interface PublishResult {
+        success: boolean;
+        toolName: string;
+        version: string;
+        url?: string;
+      }
+
+      const result: PublishResult = {
+        success: true,
+        toolName: "my-tool",
+        version: "1.0.0",
+        url: "https://registry.enact.dev/tools/my-tool/1.0.0",
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.toolName).toBeDefined();
+      expect(result.version).toBeDefined();
+    });
+
+    test("error result structure", () => {
+      interface PublishError {
+        success: boolean;
+        error: string;
+        code?: string;
+      }
+
+      const error: PublishError = {
+        success: false,
+        error: "Authentication required",
+        code: "UNAUTHORIZED",
+      };
+
+      expect(error.success).toBe(false);
+      expect(error.error).toBeDefined();
+    });
+  });
+});

package/tests/commands/report.test.ts

@@ -0,0 +1,194 @@
+/**
+ * Tests for the report command
+ */
+
+import { describe, expect, test } from "bun:test";
+import { Command } from "commander";
+import { configureReportCommand } from "../../src/commands/report";
+
+describe("report command", () => {
+  describe("command configuration", () => {
+    test("configures report command on program", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      expect(reportCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      expect(reportCmd?.description()).toBe(
+        "Report security vulnerabilities or issues with a tool (creates signed attestation)"
+      );
+    });
+
+    test("accepts tool argument", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const args = reportCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThanOrEqual(1);
+      expect(args[0]?.name()).toBe("tool");
+    });
+
+    test("has required --reason option", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const opts = reportCmd?.options ?? [];
+      const reasonOpt = opts.find((o) => o.long === "--reason");
+      expect(reasonOpt).toBeDefined();
+      expect(reasonOpt?.required).toBe(true);
+    });
+
+    test("has --severity option", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const opts = reportCmd?.options ?? [];
+      const severityOpt = opts.find((o) => o.long === "--severity");
+      expect(severityOpt).toBeDefined();
+    });
+
+    test("has --category option", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const opts = reportCmd?.options ?? [];
+      const categoryOpt = opts.find((o) => o.long === "--category");
+      expect(categoryOpt).toBeDefined();
+    });
+
+    test("has --dry-run option", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const opts = reportCmd?.options ?? [];
+      const dryRunOpt = opts.find((o) => o.long === "--dry-run");
+      expect(dryRunOpt).toBeDefined();
+    });
+
+    test("has --verbose option", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const opts = reportCmd?.options ?? [];
+      const verboseOpt = opts.find((o) => o.long === "--verbose");
+      expect(verboseOpt).toBeDefined();
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const opts = reportCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+  });
+
+  describe("severity levels", () => {
+    const severityLevels = ["critical", "high", "medium", "low"];
+
+    test("supports critical severity", () => {
+      expect(severityLevels).toContain("critical");
+    });
+
+    test("supports high severity", () => {
+      expect(severityLevels).toContain("high");
+    });
+
+    test("supports medium severity", () => {
+      expect(severityLevels).toContain("medium");
+    });
+
+    test("supports low severity", () => {
+      expect(severityLevels).toContain("low");
+    });
+
+    test("default severity is medium", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const opts = reportCmd?.options ?? [];
+      const severityOpt = opts.find((o) => o.long === "--severity");
+      expect(severityOpt?.defaultValue).toBe("medium");
+    });
+  });
+
+  describe("category types", () => {
+    const categories = ["security", "malware", "quality", "license", "other"];
+
+    test("supports security category", () => {
+      expect(categories).toContain("security");
+    });
+
+    test("supports malware category", () => {
+      expect(categories).toContain("malware");
+    });
+
+    test("supports quality category", () => {
+      expect(categories).toContain("quality");
+    });
+
+    test("supports license category", () => {
+      expect(categories).toContain("license");
+    });
+
+    test("supports other category", () => {
+      expect(categories).toContain("other");
+    });
+
+    test("default category is other", () => {
+      const program = new Command();
+      configureReportCommand(program);
+
+      const reportCmd = program.commands.find((cmd) => cmd.name() === "report");
+      const opts = reportCmd?.options ?? [];
+      const categoryOpt = opts.find((o) => o.long === "--category");
+      expect(categoryOpt?.defaultValue).toBe("other");
+    });
+  });
+
+  describe("tool@version parsing", () => {
+    test("parses tool name without version", () => {
+      const toolArg = "alice/utils/greeter";
+      const atIndex = toolArg.lastIndexOf("@");
+      expect(atIndex).toBe(-1); // No @ in this string
+    });
+
+    test("parses tool name with version", () => {
+      const toolArg = "alice/utils/greeter@1.0.0";
+      const atIndex = toolArg.lastIndexOf("@");
+      expect(atIndex).toBeGreaterThan(0);
+      expect(toolArg.slice(0, atIndex)).toBe("alice/utils/greeter");
+      expect(toolArg.slice(atIndex + 1)).toBe("1.0.0");
+    });
+
+    test("parses scoped package without version", () => {
+      const toolArg = "@scope/package";
+      // Should not split on the first @
+      expect(toolArg.startsWith("@")).toBe(true);
+    });
+
+    test("parses scoped package with version", () => {
+      const toolArg = "@scope/package@2.0.0";
+      const match = toolArg.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
+      expect(match).toBeDefined();
+      expect(match?.[1]).toBe("@scope/package");
+      expect(match?.[2]).toBe("2.0.0");
+    });
+  });
+});