@enactprotocol/cli 1.2.8 → 2.0.0

package/tests/types.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Tests for CLI types
+ */
+
+import { describe, expect, test } from "bun:test";
+import { type CommandContext, ExitCode, type GlobalOptions } from "../src/types";
+
+describe("CLI Types", () => {
+  describe("ExitCode", () => {
+    test("Success is 0", () => {
+      expect(ExitCode.Success).toBe(0);
+    });
+
+    test("Error is 1", () => {
+      expect(ExitCode.Error).toBe(1);
+    });
+
+    test("InvalidArgs is 2", () => {
+      expect(ExitCode.InvalidArgs).toBe(2);
+    });
+
+    test("NotFound is 3", () => {
+      expect(ExitCode.NotFound).toBe(3);
+    });
+
+    test("PermissionDenied is 4", () => {
+      expect(ExitCode.PermissionDenied).toBe(4);
+    });
+
+    test("Cancelled is 130 (standard for Ctrl+C)", () => {
+      expect(ExitCode.Cancelled).toBe(130);
+    });
+  });
+
+  describe("GlobalOptions interface", () => {
+    test("accepts valid options", () => {
+      const options: GlobalOptions = {
+        verbose: true,
+        json: false,
+        quiet: false,
+        dryRun: true,
+      };
+
+      expect(options.verbose).toBe(true);
+      expect(options.json).toBe(false);
+      expect(options.quiet).toBe(false);
+      expect(options.dryRun).toBe(true);
+    });
+
+    test("all properties are optional", () => {
+      const options: GlobalOptions = {};
+      expect(options.verbose).toBeUndefined();
+      expect(options.json).toBeUndefined();
+    });
+  });
+
+  describe("CommandContext interface", () => {
+    test("accepts valid context", () => {
+      const ctx: CommandContext = {
+        cwd: "/test/path",
+        options: { verbose: true },
+        isCI: false,
+        isInteractive: true,
+      };
+
+      expect(ctx.cwd).toBe("/test/path");
+      expect(ctx.options.verbose).toBe(true);
+      expect(ctx.isCI).toBe(false);
+      expect(ctx.isInteractive).toBe(true);
+    });
+
+    test("CI environment detection", () => {
+      const ciCtx: CommandContext = {
+        cwd: "/test",
+        options: {},
+        isCI: true,
+        isInteractive: false,
+      };
+
+      expect(ciCtx.isCI).toBe(true);
+      expect(ciCtx.isInteractive).toBe(false);
+    });
+  });
+});

package/tests/utils/errors.test.ts

@@ -0,0 +1,303 @@
+/**
+ * Tests for error handling utilities
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  AuthError,
+  CliError,
+  ConfigError,
+  ContainerError,
+  EXIT_AUTH_ERROR,
+  EXIT_CONFIG,
+  EXIT_CONTAINER_ERROR,
+  EXIT_EXECUTION_ERROR,
+  EXIT_FAILURE,
+  EXIT_MANIFEST_ERROR,
+  EXIT_NETWORK_ERROR,
+  EXIT_NOINPUT,
+  EXIT_NOPERM,
+  EXIT_REGISTRY_ERROR,
+  EXIT_TIMEOUT,
+  EXIT_TOOL_NOT_FOUND,
+  EXIT_TRUST_ERROR,
+  EXIT_USAGE,
+  EXIT_VALIDATION_ERROR,
+  ErrorMessages,
+  ExecutionError,
+  FileNotFoundError,
+  ManifestError,
+  NetworkError,
+  PermissionError,
+  RegistryError,
+  TimeoutError,
+  ToolNotFoundError,
+  TrustError,
+  UsageError,
+  ValidationError,
+  categorizeError,
+} from "../../src/utils";
+
+describe("error classes", () => {
+  describe("CliError", () => {
+    test("creates error with default exit code", () => {
+      const err = new CliError("test message");
+      expect(err.message).toBe("test message");
+      expect(err.exitCode).toBe(EXIT_FAILURE);
+      expect(err.suggestion).toBeUndefined();
+    });
+
+    test("creates error with custom exit code", () => {
+      const err = new CliError("test", 42);
+      expect(err.exitCode).toBe(42);
+    });
+
+    test("creates error with suggestion", () => {
+      const err = new CliError("test", 1, "Try this instead");
+      expect(err.suggestion).toBe("Try this instead");
+    });
+  });
+
+  describe("ToolNotFoundError", () => {
+    test("creates error with correct exit code", () => {
+      const err = new ToolNotFoundError("my-tool");
+      expect(err.message).toBe("Tool not found: my-tool");
+      expect(err.exitCode).toBe(EXIT_TOOL_NOT_FOUND);
+      expect(err.suggestion).toContain("owner/namespace/tool");
+    });
+  });
+
+  describe("ManifestError", () => {
+    test("creates error without path", () => {
+      const err = new ManifestError("Invalid manifest");
+      expect(err.message).toBe("Invalid manifest");
+      expect(err.exitCode).toBe(EXIT_MANIFEST_ERROR);
+    });
+
+    test("creates error with path", () => {
+      const err = new ManifestError("Invalid manifest", "/path/to/dir");
+      expect(err.message).toBe("Invalid manifest in /path/to/dir");
+    });
+  });
+
+  describe("ValidationError", () => {
+    test("creates error without field", () => {
+      const err = new ValidationError("must be a string");
+      expect(err.message).toBe("must be a string");
+      expect(err.exitCode).toBe(EXIT_VALIDATION_ERROR);
+    });
+
+    test("creates error with field", () => {
+      const err = new ValidationError("must be a string", "name");
+      expect(err.message).toBe("Invalid name: must be a string");
+    });
+  });
+
+  describe("AuthError", () => {
+    test("creates error with auth suggestion", () => {
+      const err = new AuthError("Not authenticated");
+      expect(err.exitCode).toBe(EXIT_AUTH_ERROR);
+      expect(err.suggestion).toContain("enact auth login");
+    });
+  });
+
+  describe("NetworkError", () => {
+    test("creates error with network suggestion", () => {
+      const err = new NetworkError("Connection refused");
+      expect(err.exitCode).toBe(EXIT_NETWORK_ERROR);
+      expect(err.suggestion).toContain("network connection");
+    });
+  });
+
+  describe("RegistryError", () => {
+    test("creates error with registry suggestion", () => {
+      const err = new RegistryError("Registry unavailable");
+      expect(err.exitCode).toBe(EXIT_REGISTRY_ERROR);
+      expect(err.suggestion).toContain("temporarily unavailable");
+    });
+  });
+
+  describe("TrustError", () => {
+    test("creates error with trust suggestion", () => {
+      const err = new TrustError("Verification failed");
+      expect(err.exitCode).toBe(EXIT_TRUST_ERROR);
+      expect(err.suggestion).toContain("enact trust check");
+    });
+  });
+
+  describe("TimeoutError", () => {
+    test("creates error with timeout details", () => {
+      const err = new TimeoutError("Download", 30000);
+      expect(err.message).toBe("Download timed out after 30s");
+      expect(err.exitCode).toBe(EXIT_TIMEOUT);
+      expect(err.suggestion).toContain("--timeout");
+    });
+  });
+
+  describe("ExecutionError", () => {
+    test("creates error with stderr", () => {
+      const err = new ExecutionError("Tool failed", "Error: something went wrong");
+      expect(err.exitCode).toBe(EXIT_EXECUTION_ERROR);
+      expect(err.stderr).toBe("Error: something went wrong");
+    });
+  });
+
+  describe("ContainerError", () => {
+    test("creates error with container suggestion", () => {
+      const err = new ContainerError("Docker not found");
+      expect(err.exitCode).toBe(EXIT_CONTAINER_ERROR);
+      expect(err.suggestion).toContain("Docker");
+    });
+  });
+
+  describe("FileNotFoundError", () => {
+    test("creates error with file path", () => {
+      const err = new FileNotFoundError("/path/to/file");
+      expect(err.message).toBe("File not found: /path/to/file");
+      expect(err.exitCode).toBe(EXIT_NOINPUT);
+    });
+  });
+
+  describe("PermissionError", () => {
+    test("creates error with path", () => {
+      const err = new PermissionError("/etc/passwd");
+      expect(err.message).toBe("Permission denied: /etc/passwd");
+      expect(err.exitCode).toBe(EXIT_NOPERM);
+    });
+  });
+
+  describe("ConfigError", () => {
+    test("creates error with config suggestion", () => {
+      const err = new ConfigError("Invalid config");
+      expect(err.exitCode).toBe(EXIT_CONFIG);
+      expect(err.suggestion).toContain("enact config list");
+    });
+  });
+
+  describe("UsageError", () => {
+    test("creates error with usage exit code", () => {
+      const err = new UsageError("Missing argument");
+      expect(err.exitCode).toBe(EXIT_USAGE);
+    });
+  });
+});
+
+describe("categorizeError", () => {
+  test("returns CliError as-is", () => {
+    const original = new ToolNotFoundError("test");
+    const result = categorizeError(original);
+    expect(result).toBe(original);
+  });
+
+  test("categorizes network errors", () => {
+    const err = new Error("ECONNREFUSED");
+    const result = categorizeError(err);
+    expect(result).toBeInstanceOf(NetworkError);
+  });
+
+  test("categorizes permission errors", () => {
+    const err = new Error("EACCES: permission denied");
+    const result = categorizeError(err);
+    expect(result).toBeInstanceOf(PermissionError);
+  });
+
+  test("categorizes file not found errors", () => {
+    const err = new Error("ENOENT: no such file or directory");
+    const result = categorizeError(err);
+    expect(result).toBeInstanceOf(FileNotFoundError);
+  });
+
+  test("categorizes timeout errors", () => {
+    const err = new Error("Request timed out");
+    const result = categorizeError(err);
+    expect(result).toBeInstanceOf(TimeoutError);
+  });
+
+  test("categorizes auth errors", () => {
+    const err = new Error("401 Unauthorized");
+    const result = categorizeError(err);
+    expect(result).toBeInstanceOf(AuthError);
+  });
+
+  test("returns generic CliError for unknown errors", () => {
+    const err = new Error("Unknown error");
+    const result = categorizeError(err);
+    expect(result).toBeInstanceOf(CliError);
+    expect(result.message).toBe("Unknown error");
+  });
+
+  test("handles non-Error objects", () => {
+    const result = categorizeError("string error");
+    expect(result).toBeInstanceOf(CliError);
+    expect(result.message).toBe("string error");
+  });
+});
+
+describe("ErrorMessages", () => {
+  describe("toolNotFound", () => {
+    test("returns structured error info", () => {
+      const info = ErrorMessages.toolNotFound("my-tool");
+      expect(info.message).toContain("my-tool");
+      expect(info.suggestions).toHaveLength(3);
+      expect(info.suggestions.some((s) => s.includes("search"))).toBe(true);
+    });
+  });
+
+  describe("notAuthenticated", () => {
+    test("returns structured error info", () => {
+      const info = ErrorMessages.notAuthenticated();
+      expect(info.message).toContain("not authenticated");
+      expect(info.suggestions.some((s) => s.includes("login"))).toBe(true);
+    });
+  });
+
+  describe("manifestNotFound", () => {
+    test("returns structured error info", () => {
+      const info = ErrorMessages.manifestNotFound("/my/dir");
+      expect(info.message).toContain("/my/dir");
+      expect(info.suggestions.some((s) => s.includes("init"))).toBe(true);
+    });
+  });
+
+  describe("invalidManifest", () => {
+    test("returns structured error info with errors", () => {
+      const errors = ["name is required", "version must be valid semver"];
+      const info = ErrorMessages.invalidManifest(errors);
+      expect(info.message).toBe("Invalid manifest");
+      expect(info.suggestions.some((s) => s.includes("name is required"))).toBe(true);
+    });
+  });
+
+  describe("registryUnavailable", () => {
+    test("returns structured error info", () => {
+      const info = ErrorMessages.registryUnavailable();
+      expect(info.message).toContain("unavailable");
+      expect(info.suggestions.some((s) => s.includes("internet"))).toBe(true);
+    });
+  });
+
+  describe("containerRuntimeNotFound", () => {
+    test("returns structured error info", () => {
+      const info = ErrorMessages.containerRuntimeNotFound();
+      expect(info.message).toContain("container runtime");
+      expect(info.suggestions.some((s) => s.includes("Docker"))).toBe(true);
+    });
+  });
+
+  describe("trustVerificationFailed", () => {
+    test("returns structured error info", () => {
+      const info = ErrorMessages.trustVerificationFailed("my-tool");
+      expect(info.message).toContain("my-tool");
+      expect(info.suggestions.some((s) => s.includes("enact trust"))).toBe(true);
+    });
+  });
+
+  describe("executionFailed", () => {
+    test("returns structured error info", () => {
+      const info = ErrorMessages.executionFailed("my-tool", 1);
+      expect(info.message).toContain("my-tool");
+      expect(info.message).toContain("exit code 1");
+      expect(info.suggestions.some((s) => s.includes("--verbose"))).toBe(true);
+    });
+  });
+});

package/tests/utils/exit-codes.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Tests for exit codes
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  EXIT_AUTH_ERROR,
+  EXIT_CANTCREAT,
+  EXIT_CONFIG,
+  EXIT_CONTAINER_ERROR,
+  EXIT_DATAERR,
+  EXIT_EXECUTION_ERROR,
+  EXIT_FAILURE,
+  EXIT_IOERR,
+  EXIT_MANIFEST_ERROR,
+  EXIT_NETWORK_ERROR,
+  EXIT_NOHOST,
+  EXIT_NOINPUT,
+  EXIT_NOPERM,
+  EXIT_NOUSER,
+  EXIT_OSERR,
+  EXIT_OSFILE,
+  EXIT_PROTOCOL,
+  EXIT_REGISTRY_ERROR,
+  EXIT_SOFTWARE,
+  EXIT_SUCCESS,
+  EXIT_TEMPFAIL,
+  EXIT_TIMEOUT,
+  EXIT_TOOL_NOT_FOUND,
+  EXIT_TRUST_ERROR,
+  EXIT_UNAVAILABLE,
+  EXIT_USAGE,
+  EXIT_VALIDATION_ERROR,
+  getExitCodeDescription,
+} from "../../src/utils";
+
+describe("exit codes", () => {
+  describe("standard exit codes", () => {
+    test("EXIT_SUCCESS is 0", () => {
+      expect(EXIT_SUCCESS).toBe(0);
+    });
+
+    test("EXIT_FAILURE is 1", () => {
+      expect(EXIT_FAILURE).toBe(1);
+    });
+
+    test("EXIT_USAGE is 2", () => {
+      expect(EXIT_USAGE).toBe(2);
+    });
+  });
+
+  describe("sysexits.h compatible codes", () => {
+    test("EXIT_DATAERR is 65", () => {
+      expect(EXIT_DATAERR).toBe(65);
+    });
+
+    test("EXIT_NOINPUT is 66", () => {
+      expect(EXIT_NOINPUT).toBe(66);
+    });
+
+    test("EXIT_NOUSER is 67", () => {
+      expect(EXIT_NOUSER).toBe(67);
+    });
+
+    test("EXIT_NOHOST is 68", () => {
+      expect(EXIT_NOHOST).toBe(68);
+    });
+
+    test("EXIT_UNAVAILABLE is 69", () => {
+      expect(EXIT_UNAVAILABLE).toBe(69);
+    });
+
+    test("EXIT_SOFTWARE is 70", () => {
+      expect(EXIT_SOFTWARE).toBe(70);
+    });
+
+    test("EXIT_OSERR is 71", () => {
+      expect(EXIT_OSERR).toBe(71);
+    });
+
+    test("EXIT_OSFILE is 72", () => {
+      expect(EXIT_OSFILE).toBe(72);
+    });
+
+    test("EXIT_CANTCREAT is 73", () => {
+      expect(EXIT_CANTCREAT).toBe(73);
+    });
+
+    test("EXIT_IOERR is 74", () => {
+      expect(EXIT_IOERR).toBe(74);
+    });
+
+    test("EXIT_TEMPFAIL is 75", () => {
+      expect(EXIT_TEMPFAIL).toBe(75);
+    });
+
+    test("EXIT_PROTOCOL is 76", () => {
+      expect(EXIT_PROTOCOL).toBe(76);
+    });
+
+    test("EXIT_NOPERM is 77", () => {
+      expect(EXIT_NOPERM).toBe(77);
+    });
+
+    test("EXIT_CONFIG is 78", () => {
+      expect(EXIT_CONFIG).toBe(78);
+    });
+  });
+
+  describe("enact-specific codes", () => {
+    test("EXIT_TOOL_NOT_FOUND is 100", () => {
+      expect(EXIT_TOOL_NOT_FOUND).toBe(100);
+    });
+
+    test("EXIT_MANIFEST_ERROR is 101", () => {
+      expect(EXIT_MANIFEST_ERROR).toBe(101);
+    });
+
+    test("EXIT_EXECUTION_ERROR is 102", () => {
+      expect(EXIT_EXECUTION_ERROR).toBe(102);
+    });
+
+    test("EXIT_TIMEOUT is 103", () => {
+      expect(EXIT_TIMEOUT).toBe(103);
+    });
+
+    test("EXIT_TRUST_ERROR is 104", () => {
+      expect(EXIT_TRUST_ERROR).toBe(104);
+    });
+
+    test("EXIT_REGISTRY_ERROR is 105", () => {
+      expect(EXIT_REGISTRY_ERROR).toBe(105);
+    });
+
+    test("EXIT_AUTH_ERROR is 106", () => {
+      expect(EXIT_AUTH_ERROR).toBe(106);
+    });
+
+    test("EXIT_VALIDATION_ERROR is 107", () => {
+      expect(EXIT_VALIDATION_ERROR).toBe(107);
+    });
+
+    test("EXIT_NETWORK_ERROR is 108", () => {
+      expect(EXIT_NETWORK_ERROR).toBe(108);
+    });
+
+    test("EXIT_CONTAINER_ERROR is 109", () => {
+      expect(EXIT_CONTAINER_ERROR).toBe(109);
+    });
+  });
+
+  describe("getExitCodeDescription", () => {
+    test("describes EXIT_SUCCESS", () => {
+      expect(getExitCodeDescription(EXIT_SUCCESS)).toBe("Success");
+    });
+
+    test("describes EXIT_FAILURE", () => {
+      expect(getExitCodeDescription(EXIT_FAILURE)).toBe("General error");
+    });
+
+    test("describes EXIT_USAGE", () => {
+      expect(getExitCodeDescription(EXIT_USAGE)).toBe("Invalid command line arguments");
+    });
+
+    test("describes EXIT_TOOL_NOT_FOUND", () => {
+      expect(getExitCodeDescription(EXIT_TOOL_NOT_FOUND)).toBe("Tool not found");
+    });
+
+    test("describes EXIT_MANIFEST_ERROR", () => {
+      expect(getExitCodeDescription(EXIT_MANIFEST_ERROR)).toBe("Manifest error");
+    });
+
+    test("describes EXIT_TRUST_ERROR", () => {
+      expect(getExitCodeDescription(EXIT_TRUST_ERROR)).toBe("Trust verification failed");
+    });
+
+    test("describes EXIT_AUTH_ERROR", () => {
+      expect(getExitCodeDescription(EXIT_AUTH_ERROR)).toBe("Authentication error");
+    });
+
+    test("describes EXIT_REGISTRY_ERROR", () => {
+      expect(getExitCodeDescription(EXIT_REGISTRY_ERROR)).toBe("Registry error");
+    });
+
+    test("returns unknown for unrecognized codes", () => {
+      expect(getExitCodeDescription(999)).toBe("Unknown error (code 999)");
+    });
+  });
+});