@enactprotocol/cli 1.2.8 → 2.0.0

package/tests/commands/config.test.ts

@@ -0,0 +1,277 @@
+/**
+ * Tests for the config 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 { configureConfigCommand } from "../../src/commands/config";
+
+// Test fixtures directory
+const FIXTURES_DIR = join(import.meta.dir, "..", "fixtures", "config-cmd");
+
+describe("config 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 config command on program", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      expect(configCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      expect(configCmd?.description()).toBe("Manage CLI configuration");
+    });
+
+    test("has get subcommand", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const getCmd = configCmd?.commands.find((cmd) => cmd.name() === "get");
+      expect(getCmd).toBeDefined();
+    });
+
+    test("has set subcommand", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const setCmd = configCmd?.commands.find((cmd) => cmd.name() === "set");
+      expect(setCmd).toBeDefined();
+    });
+
+    test("has list subcommand", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const listCmd = configCmd?.commands.find((cmd) => cmd.name() === "list");
+      expect(listCmd).toBeDefined();
+    });
+  });
+
+  describe("config get subcommand", () => {
+    test("has key argument", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const getCmd = configCmd?.commands.find((cmd) => cmd.name() === "get");
+      const args = getCmd?.registeredArguments ?? [];
+      expect(args.length).toBe(1);
+      expect(args[0]?.name()).toBe("key");
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const getCmd = configCmd?.commands.find((cmd) => cmd.name() === "get");
+      const opts = getCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+  });
+
+  describe("config set subcommand", () => {
+    test("has key argument", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const setCmd = configCmd?.commands.find((cmd) => cmd.name() === "set");
+      const args = setCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThanOrEqual(1);
+      expect(args[0]?.name()).toBe("key");
+    });
+
+    test("has value argument", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const setCmd = configCmd?.commands.find((cmd) => cmd.name() === "set");
+      const args = setCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThanOrEqual(2);
+      expect(args[1]?.name()).toBe("value");
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const setCmd = configCmd?.commands.find((cmd) => cmd.name() === "set");
+      const opts = setCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+  });
+
+  describe("config list subcommand", () => {
+    test("has --json option", () => {
+      const program = new Command();
+      configureConfigCommand(program);
+
+      const configCmd = program.commands.find((cmd) => cmd.name() === "config");
+      const listCmd = configCmd?.commands.find((cmd) => cmd.name() === "list");
+      const opts = listCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+  });
+
+  describe("dot notation key parsing", () => {
+    test("parses simple keys", () => {
+      const key = "version";
+      const parts = key.split(".");
+      expect(parts).toEqual(["version"]);
+    });
+
+    test("parses nested keys", () => {
+      const key = "trust.policy";
+      const parts = key.split(".");
+      expect(parts).toEqual(["trust", "policy"]);
+    });
+
+    test("parses deeply nested keys", () => {
+      const key = "registry.auth.token";
+      const parts = key.split(".");
+      expect(parts).toEqual(["registry", "auth", "token"]);
+    });
+
+    test("gets value from nested object", () => {
+      const config = {
+        trust: {
+          policy: "warn",
+          publishers: ["alice"],
+        },
+        cache: {
+          maxSizeMb: 1024,
+        },
+      };
+
+      const getValue = (obj: Record<string, unknown>, key: string): unknown => {
+        const parts = key.split(".");
+        let current: unknown = obj;
+        for (const part of parts) {
+          if (current === null || typeof current !== "object") {
+            return undefined;
+          }
+          current = (current as Record<string, unknown>)[part];
+        }
+        return current;
+      };
+
+      expect(getValue(config, "trust.policy")).toBe("warn");
+      expect(getValue(config, "cache.maxSizeMb")).toBe(1024);
+      expect(getValue(config, "trust.publishers")).toEqual(["alice"]);
+      expect(getValue(config, "nonexistent")).toBeUndefined();
+    });
+
+    test("sets value in nested object", () => {
+      const config: Record<string, unknown> = {
+        trust: {
+          policy: "warn",
+        },
+      };
+
+      const setValue = (obj: Record<string, unknown>, key: string, value: unknown): void => {
+        const parts = key.split(".");
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+          const part = parts[i] as string;
+          if (!(part in current) || typeof current[part] !== "object") {
+            current[part] = {};
+          }
+          current = current[part] as Record<string, unknown>;
+        }
+        const lastPart = parts[parts.length - 1] as string;
+        current[lastPart] = value;
+      };
+
+      setValue(config, "trust.policy", "strict");
+      expect((config.trust as Record<string, unknown>).policy).toBe("strict");
+
+      setValue(config, "newKey", "value");
+      expect(config.newKey).toBe("value");
+
+      setValue(config, "deep.nested.key", 123);
+      expect(((config.deep as Record<string, unknown>).nested as Record<string, unknown>).key).toBe(
+        123
+      );
+    });
+  });
+
+  describe("value parsing", () => {
+    test("parses JSON object values", () => {
+      const value = '{"enabled": true}';
+      const parsed = JSON.parse(value);
+      expect(parsed.enabled).toBe(true);
+    });
+
+    test("parses JSON array values", () => {
+      const value = '["alice", "bob"]';
+      const parsed = JSON.parse(value);
+      expect(parsed).toEqual(["alice", "bob"]);
+    });
+
+    test("parses number values", () => {
+      const value = "1024";
+      const parsed = JSON.parse(value);
+      expect(parsed).toBe(1024);
+    });
+
+    test("parses boolean values", () => {
+      expect(JSON.parse("true")).toBe(true);
+      expect(JSON.parse("false")).toBe(false);
+    });
+
+    test("keeps string values as-is when not valid JSON", () => {
+      const value = "simple-string";
+      let parsed: unknown = value;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        // Keep as string
+      }
+      expect(parsed).toBe("simple-string");
+    });
+
+    test("keeps URL values as strings", () => {
+      const value = "https://enact.tools";
+      let parsed: unknown = value;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        // Keep as string
+      }
+      expect(parsed).toBe("https://enact.tools");
+    });
+  });
+});

package/tests/commands/env.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Tests for the env 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 { configureEnvCommand } from "../../src/commands/env";
+
+// Test fixtures directory
+const FIXTURES_DIR = join(import.meta.dir, "..", "fixtures", "env-cmd");
+
+describe("env 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 env command on program", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      expect(envCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      expect(envCmd?.description()).toBe("Manage environment variables and secrets");
+    });
+
+    test("has set subcommand", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const setCmd = envCmd?.commands.find((cmd) => cmd.name() === "set");
+      expect(setCmd).toBeDefined();
+    });
+
+    test("has get subcommand", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const getCmd = envCmd?.commands.find((cmd) => cmd.name() === "get");
+      expect(getCmd).toBeDefined();
+    });
+
+    test("has list subcommand", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const listCmd = envCmd?.commands.find((cmd) => cmd.name() === "list");
+      expect(listCmd).toBeDefined();
+    });
+
+    test("has delete subcommand", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const deleteCmd = envCmd?.commands.find((cmd) => cmd.name() === "delete");
+      expect(deleteCmd).toBeDefined();
+    });
+
+    test("delete has rm alias", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const deleteCmd = envCmd?.commands.find((cmd) => cmd.name() === "delete");
+      const aliases = deleteCmd?.aliases() ?? [];
+      expect(aliases).toContain("rm");
+    });
+  });
+
+  describe("env set subcommand", () => {
+    test("has key argument", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const setCmd = envCmd?.commands.find((cmd) => cmd.name() === "set");
+      const args = setCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThanOrEqual(1);
+      expect(args[0]?.name()).toBe("key");
+    });
+
+    test("has optional value argument", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const setCmd = envCmd?.commands.find((cmd) => cmd.name() === "set");
+      const args = setCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThanOrEqual(2);
+      expect(args[1]?.name()).toBe("value");
+      expect(args[1]?.required).toBe(false);
+    });
+
+    test("has --secret option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const setCmd = envCmd?.commands.find((cmd) => cmd.name() === "set");
+      const opts = setCmd?.options ?? [];
+      const secretOpt = opts.find((o) => o.long === "--secret");
+      expect(secretOpt).toBeDefined();
+    });
+
+    test("has --namespace option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const setCmd = envCmd?.commands.find((cmd) => cmd.name() === "set");
+      const opts = setCmd?.options ?? [];
+      const namespaceOpt = opts.find((o) => o.long === "--namespace");
+      expect(namespaceOpt).toBeDefined();
+    });
+
+    test("has --local option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const setCmd = envCmd?.commands.find((cmd) => cmd.name() === "set");
+      const opts = setCmd?.options ?? [];
+      const localOpt = opts.find((o) => o.long === "--local");
+      expect(localOpt).toBeDefined();
+    });
+  });
+
+  describe("env get subcommand", () => {
+    test("has key argument", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const getCmd = envCmd?.commands.find((cmd) => cmd.name() === "get");
+      const args = getCmd?.registeredArguments ?? [];
+      expect(args.length).toBe(1);
+      expect(args[0]?.name()).toBe("key");
+    });
+
+    test("has --secret option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const getCmd = envCmd?.commands.find((cmd) => cmd.name() === "get");
+      const opts = getCmd?.options ?? [];
+      const secretOpt = opts.find((o) => o.long === "--secret");
+      expect(secretOpt).toBeDefined();
+    });
+
+    test("has --namespace option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const getCmd = envCmd?.commands.find((cmd) => cmd.name() === "get");
+      const opts = getCmd?.options ?? [];
+      const namespaceOpt = opts.find((o) => o.long === "--namespace");
+      expect(namespaceOpt).toBeDefined();
+    });
+  });
+
+  describe("env list subcommand", () => {
+    test("has --secret option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const listCmd = envCmd?.commands.find((cmd) => cmd.name() === "list");
+      const opts = listCmd?.options ?? [];
+      const secretOpt = opts.find((o) => o.long === "--secret");
+      expect(secretOpt).toBeDefined();
+    });
+
+    test("has --local option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const listCmd = envCmd?.commands.find((cmd) => cmd.name() === "list");
+      const opts = listCmd?.options ?? [];
+      const localOpt = opts.find((o) => o.long === "--local");
+      expect(localOpt).toBeDefined();
+    });
+
+    test("has --global option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const listCmd = envCmd?.commands.find((cmd) => cmd.name() === "list");
+      const opts = listCmd?.options ?? [];
+      const globalOpt = opts.find((o) => o.long === "--global");
+      expect(globalOpt).toBeDefined();
+    });
+  });
+
+  describe("env delete subcommand", () => {
+    test("has key argument", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const deleteCmd = envCmd?.commands.find((cmd) => cmd.name() === "delete");
+      const args = deleteCmd?.registeredArguments ?? [];
+      expect(args.length).toBe(1);
+      expect(args[0]?.name()).toBe("key");
+    });
+
+    test("has --secret option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const deleteCmd = envCmd?.commands.find((cmd) => cmd.name() === "delete");
+      const opts = deleteCmd?.options ?? [];
+      const secretOpt = opts.find((o) => o.long === "--secret");
+      expect(secretOpt).toBeDefined();
+    });
+
+    test("has --namespace option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const deleteCmd = envCmd?.commands.find((cmd) => cmd.name() === "delete");
+      const opts = deleteCmd?.options ?? [];
+      const namespaceOpt = opts.find((o) => o.long === "--namespace");
+      expect(namespaceOpt).toBeDefined();
+    });
+
+    test("has --local option", () => {
+      const program = new Command();
+      configureEnvCommand(program);
+
+      const envCmd = program.commands.find((cmd) => cmd.name() === "env");
+      const deleteCmd = envCmd?.commands.find((cmd) => cmd.name() === "delete");
+      const opts = deleteCmd?.options ?? [];
+      const localOpt = opts.find((o) => o.long === "--local");
+      expect(localOpt).toBeDefined();
+    });
+  });
+
+  describe("secret vs env mode", () => {
+    test("secret mode requires namespace", () => {
+      const options = { secret: true, namespace: undefined };
+      const requiresNamespace = options.secret && !options.namespace;
+      expect(requiresNamespace).toBe(true);
+    });
+
+    test("secret mode with namespace is valid", () => {
+      const options = { secret: true, namespace: "alice/api" };
+      const isValid = options.secret && options.namespace;
+      expect(isValid).toBeTruthy();
+    });
+
+    test("env mode does not require namespace", () => {
+      const options = { secret: false };
+      expect(options.secret).toBe(false);
+    });
+
+    test("local option applies to env mode", () => {
+      const options = { secret: false, local: true };
+      expect(options.local).toBe(true);
+    });
+  });
+});

package/tests/commands/exec.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Tests for the exec command
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { Command } from "commander";
+import { configureExecCommand } from "../../src/commands/exec";
+
+// Test fixtures directory
+const FIXTURES_DIR = join(import.meta.dir, "..", "fixtures", "exec-cmd");
+
+describe("exec command", () => {
+  beforeAll(() => {
+    mkdirSync(FIXTURES_DIR, { recursive: true });
+  });
+
+  afterAll(() => {
+    if (existsSync(FIXTURES_DIR)) {
+      rmSync(FIXTURES_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("command configuration", () => {
+    test("configures exec command on program", () => {
+      const program = new Command();
+      configureExecCommand(program);
+
+      const execCmd = program.commands.find((cmd) => cmd.name() === "exec");
+      expect(execCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configureExecCommand(program);
+
+      const execCmd = program.commands.find((cmd) => cmd.name() === "exec");
+      expect(execCmd?.description()).toBe(
+        "Execute an arbitrary command in a tool's container environment"
+      );
+    });
+
+    test("accepts tool argument", () => {
+      const program = new Command();
+      configureExecCommand(program);
+
+      const execCmd = program.commands.find((cmd) => cmd.name() === "exec");
+      const args = execCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThanOrEqual(1);
+      expect(args[0]?.name()).toBe("tool");
+    });
+
+    test("accepts command argument", () => {
+      const program = new Command();
+      configureExecCommand(program);
+
+      const execCmd = program.commands.find((cmd) => cmd.name() === "exec");
+      const args = execCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThanOrEqual(2);
+      expect(args[1]?.name()).toBe("command");
+    });
+
+    test("has --timeout option", () => {
+      const program = new Command();
+      configureExecCommand(program);
+
+      const execCmd = program.commands.find((cmd) => cmd.name() === "exec");
+      const opts = execCmd?.options ?? [];
+      const timeoutOpt = opts.find((o) => o.long === "--timeout");
+      expect(timeoutOpt).toBeDefined();
+    });
+
+    test("has --verbose option", () => {
+      const program = new Command();
+      configureExecCommand(program);
+
+      const execCmd = program.commands.find((cmd) => cmd.name() === "exec");
+      const opts = execCmd?.options ?? [];
+      const verboseOpt = opts.find((o) => o.long === "--verbose");
+      expect(verboseOpt).toBeDefined();
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configureExecCommand(program);
+
+      const execCmd = program.commands.find((cmd) => cmd.name() === "exec");
+      const opts = execCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+  });
+
+  describe("command parsing", () => {
+    test("command with spaces should be quoted", () => {
+      const command = 'echo "Hello World"';
+      expect(command).toContain(" ");
+      expect(command).toContain('"');
+    });
+
+    test("complex shell commands", () => {
+      const command = "ls -la && cat enact.md";
+      expect(command).toContain("&&");
+    });
+
+    test("command with pipes", () => {
+      const command = "cat file.txt | grep pattern | wc -l";
+      expect(command).toContain("|");
+    });
+  });
+});