@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.0

package/tests/service/completion/shell/bash.test.ts

@@ -0,0 +1,73 @@
+import process from "node:process";
+import path from "node:path";
+import { describe, expect, test } from "bun:test";
+import BashShellHandler from "../../../../src/service/completion/shell/bash.ts";
+
+describe("BashShellHandler", () => {
+  const handler = new BashShellHandler();
+
+  test("getDefaultConfigPath returns ~/.bashrc", () => {
+    const configPath = handler.getDefaultConfigPath();
+    expect(configPath).toEndWith(path.sep + ".bashrc");
+  });
+
+  test("getBootstrapScript generates correct function", () => {
+    const script = handler.getBootstrapScript("mycli");
+    expect(script).toContain("_mycli_completions()");
+    expect(script).toContain("COMPREPLY=");
+    expect(script).toContain("mycli completions:complete bash");
+    expect(script).toContain("COMP_LINE");
+    expect(script).toContain("COMP_POINT");
+    expect(script).toContain("complete -F _mycli_completions mycli");
+  });
+
+  test("formatCompletions outputs one value per line", () => {
+    const result = handler.formatCompletions([
+      { value: "help", description: "Display help" },
+      { value: "version", description: "Show version" },
+    ]);
+    expect(result).toEqual("help\nversion");
+  });
+
+  test("formatCompletions handles empty list", () => {
+    expect(handler.formatCompletions([])).toEqual("");
+  });
+
+  test("parseCompletionContext extracts line and cursor position", () => {
+    const ctx = handler.parseCompletionContext(["mycli he", "8"]);
+    expect(ctx.line).toEqual("mycli he");
+    expect(ctx.cursorPosition).toEqual(8);
+  });
+
+  test("parseCompletionContext handles missing args", () => {
+    const ctx = handler.parseCompletionContext([]);
+    expect(ctx.line).toEqual("");
+    expect(ctx.cursorPosition).toEqual(0);
+  });
+
+  describe("validateEnvironment", () => {
+    const originalShell = process.env.SHELL;
+
+    test("returns true when SHELL ends with /bash", async () => {
+      process.env.SHELL = "/bin/bash";
+      const result = await handler.validateEnvironment();
+      expect(result).toBe(true);
+      process.env.SHELL = originalShell;
+    });
+
+    test("falls back to spawning bash --version when SHELL is not bash", async () => {
+      process.env.SHELL = "/bin/zsh";
+      const result = await handler.validateEnvironment();
+      // Result depends on whether bash is installed; just verify it returns a boolean
+      expect(typeof result).toBe("boolean");
+      process.env.SHELL = originalShell;
+    });
+
+    test("falls back to spawning bash --version when SHELL is empty", async () => {
+      process.env.SHELL = "";
+      const result = await handler.validateEnvironment();
+      expect(typeof result).toBe("boolean");
+      process.env.SHELL = originalShell;
+    });
+  });
+});

package/tests/service/completion/shell/fish.test.ts

@@ -0,0 +1,62 @@
+import process from "node:process";
+import path from "node:path";
+import { describe, expect, test } from "bun:test";
+import FishShellHandler from "../../../../src/service/completion/shell/fish.ts";
+
+describe("FishShellHandler", () => {
+  const handler = new FishShellHandler();
+
+  test("getDefaultConfigPath returns fish config.fish", () => {
+    const configPath = handler.getDefaultConfigPath();
+    expect(configPath).toEndWith(
+      path.sep + path.join(".config", "fish", "config.fish"),
+    );
+  });
+
+  test("getBootstrapScript generates correct complete command", () => {
+    const script = handler.getBootstrapScript("mycli");
+    expect(script).toContain("complete -c mycli");
+    expect(script).toContain("mycli completions:complete fish");
+    expect(script).toContain("commandline -cp");
+    expect(script).toContain("commandline -C");
+  });
+
+  test("formatCompletions uses tab separator for descriptions", () => {
+    const result = handler.formatCompletions([
+      { value: "help", description: "Display help" },
+      { value: "version" },
+    ]);
+    expect(result).toEqual("help\tDisplay help\nversion");
+  });
+
+  test("parseCompletionContext extracts line and cursor position", () => {
+    const ctx = handler.parseCompletionContext(["mycli he", "8"]);
+    expect(ctx.line).toEqual("mycli he");
+    expect(ctx.cursorPosition).toEqual(8);
+  });
+
+  describe("validateEnvironment", () => {
+    const originalShell = process.env.SHELL;
+
+    test("returns true when SHELL ends with /fish", async () => {
+      process.env.SHELL = "/usr/bin/fish";
+      const result = await handler.validateEnvironment();
+      expect(result).toBe(true);
+      process.env.SHELL = originalShell;
+    });
+
+    test("falls back to spawning fish --version when SHELL is not fish", async () => {
+      process.env.SHELL = "/bin/bash";
+      const result = await handler.validateEnvironment();
+      expect(typeof result).toBe("boolean");
+      process.env.SHELL = originalShell;
+    });
+
+    test("falls back to spawning fish --version when SHELL is empty", async () => {
+      process.env.SHELL = "";
+      const result = await handler.validateEnvironment();
+      expect(typeof result).toBe("boolean");
+      process.env.SHELL = originalShell;
+    });
+  });
+});

package/tests/service/completion/shell/powershell.test.ts

@@ -0,0 +1,59 @@
+import process from "node:process";
+import { describe, expect, test } from "bun:test";
+import PowerShellShellHandler from "../../../../src/service/completion/shell/powershell.ts";
+
+describe("PowerShellShellHandler", () => {
+  const handler = new PowerShellShellHandler();
+
+  test("getDefaultConfigPath returns PowerShell profile path", () => {
+    const path = handler.getDefaultConfigPath();
+    expect(path).toContain("Microsoft.PowerShell_profile.ps1");
+  });
+
+  test("getBootstrapScript generates Register-ArgumentCompleter", () => {
+    const script = handler.getBootstrapScript("mycli");
+    expect(script).toContain("Register-ArgumentCompleter");
+    expect(script).toContain("-Native");
+    expect(script).toContain("-CommandName mycli");
+    expect(script).toContain("mycli completions:complete powershell");
+    expect(script).toContain("CompletionResult");
+  });
+
+  test("formatCompletions outputs one value per line", () => {
+    const result = handler.formatCompletions([
+      { value: "help", description: "Display help" },
+      { value: "version" },
+    ]);
+    expect(result).toEqual("help\nversion");
+  });
+
+  test("parseCompletionContext extracts line and cursor position", () => {
+    const ctx = handler.parseCompletionContext(["mycli he", "8"]);
+    expect(ctx.line).toEqual("mycli he");
+    expect(ctx.cursorPosition).toEqual(8);
+  });
+
+  describe("validateEnvironment", () => {
+    test("returns a boolean", async () => {
+      // validateEnvironment tries pwsh first, then powershell fallback
+      // Result depends on whether either is installed
+      const result = await handler.validateEnvironment();
+      expect(typeof result).toBe("boolean");
+    });
+  });
+
+  describe("getDefaultConfigPath platform handling", () => {
+    test("path contains Microsoft.PowerShell_profile.ps1", () => {
+      const configPath = handler.getDefaultConfigPath();
+      expect(configPath).toContain("Microsoft.PowerShell_profile.ps1");
+      // On non-win32 platforms, path should contain .config/powershell
+      if (process.platform !== "win32") {
+        expect(configPath).toContain(".config");
+        expect(configPath).toContain("powershell");
+      } else {
+        expect(configPath).toContain("Documents");
+        expect(configPath).toContain("PowerShell");
+      }
+    });
+  });
+});

package/tests/service/completion/shell/zsh.test.ts

@@ -0,0 +1,60 @@
+import process from "node:process";
+import path from "node:path";
+import { describe, expect, test } from "bun:test";
+import ZshShellHandler from "../../../../src/service/completion/shell/zsh.ts";
+
+describe("ZshShellHandler", () => {
+  const handler = new ZshShellHandler();
+
+  test("getDefaultConfigPath returns ~/.zshrc", () => {
+    const configPath = handler.getDefaultConfigPath();
+    expect(configPath).toEndWith(path.sep + ".zshrc");
+  });
+
+  test("getBootstrapScript generates correct function", () => {
+    const script = handler.getBootstrapScript("mycli");
+    expect(script).toContain("_mycli_completions()");
+    expect(script).toContain("mycli completions:complete zsh");
+    expect(script).toContain("compdef _mycli_completions mycli");
+    expect(script).toContain("_describe");
+  });
+
+  test("formatCompletions includes descriptions with colon separator", () => {
+    const result = handler.formatCompletions([
+      { value: "help", description: "Display help" },
+      { value: "version" },
+    ]);
+    expect(result).toEqual("help:Display help\nversion");
+  });
+
+  test("parseCompletionContext extracts line and cursor position", () => {
+    const ctx = handler.parseCompletionContext(["mycli he", "8"]);
+    expect(ctx.line).toEqual("mycli he");
+    expect(ctx.cursorPosition).toEqual(8);
+  });
+
+  describe("validateEnvironment", () => {
+    const originalShell = process.env.SHELL;
+
+    test("returns true when SHELL ends with /zsh", async () => {
+      process.env.SHELL = "/bin/zsh";
+      const result = await handler.validateEnvironment();
+      expect(result).toBe(true);
+      process.env.SHELL = originalShell;
+    });
+
+    test("falls back to spawning zsh --version when SHELL is not zsh", async () => {
+      process.env.SHELL = "/bin/bash";
+      const result = await handler.validateEnvironment();
+      expect(typeof result).toBe("boolean");
+      process.env.SHELL = originalShell;
+    });
+
+    test("falls back to spawning zsh --version when SHELL is empty", async () => {
+      process.env.SHELL = "";
+      const result = await handler.validateEnvironment();
+      expect(typeof result).toBe("boolean");
+      process.env.SHELL = originalShell;
+    });
+  });
+});

package/tests/service/configuration/ConfigurationServiceProvider.test.ts

@@ -61,13 +61,13 @@ function getSubCommand(): SubCommand {
   };
 }
 describe("ConfigurationServiceProvider tests", () => {
-  test("ConfigurationServiceProvider provide works", async () => {
+  test("ConfigurationServiceProvider getServiceInfo works", async () => {
     const configurationServiceProvider = new ConfigurationServiceProvider(
       100,
       false,
       true,
     );
-    const serviceInfo = await configurationServiceProvider.provide(
+    const serviceInfo = await configurationServiceProvider.getServiceInfo(
       getCLIConfig(),
     );
     expect(serviceInfo.commands.length).toEqual(2);
@@ -131,9 +131,10 @@ describe("ConfigurationServiceProvider tests", () => {
     const subCommand = getSubCommand();
 
     await configurationServiceProvider.initService(context);
+    await configurationServiceProvider.getServiceInfo(getCLIConfig());
 
     expect(
-      configurationServiceProvider.getDefaultArgumentValues(
+      await configurationServiceProvider.getDefaultArgumentValues(
         getCLIConfig(),
         subCommand,
       ),
@@ -157,9 +158,10 @@ describe("ConfigurationServiceProvider tests", () => {
       const subCommand = getSubCommand();
 
       await configurationServiceProvider.initService(context);
+      await configurationServiceProvider.getServiceInfo(getCLIConfig());
 
       expect(
-        configurationServiceProvider.getDefaultArgumentValues(
+        await configurationServiceProvider.getDefaultArgumentValues(
           getCLIConfig(),
           subCommand,
         ),
@@ -189,7 +191,9 @@ describe("ConfigurationServiceProvider tests", () => {
 
     await fs.writeFile(configLocation, JSON.stringify(config));
 
-    const serviceInfo = await configurationServiceProvider.provide(cliConfig);
+    const serviceInfo = await configurationServiceProvider.getServiceInfo(
+      cliConfig,
+    );
 
     await configurationServiceProvider.initService(context);
 
@@ -197,16 +201,16 @@ describe("ConfigurationServiceProvider tests", () => {
 
     configurationServiceProvider.setCommandKeyValueScope("command2");
 
-    expect(keyValueService.hasKey("foo2")).toBeFalse();
+    expect(await keyValueService.hasKey("foo2")).toBeFalse();
 
     await configurationServiceProvider.clearKeyValueScope();
     configurationServiceProvider.setCommandKeyValueScope("command1");
 
-    expect(keyValueService.getKey("foo2")).toEqual("bar2");
+    expect(await keyValueService.getKey("foo2")).toEqual("bar2");
 
     await configurationServiceProvider.clearKeyValueScope();
 
-    expect(() => keyValueService.hasKey("foo2")).toThrow();
+    expect(keyValueService.hasKey("foo2")).rejects.toThrow();
   });
 
   test("setServiceKeyValueScope works", async () => {
@@ -227,7 +231,9 @@ describe("ConfigurationServiceProvider tests", () => {
 
     await fs.writeFile(configLocation, JSON.stringify(config));
 
-    const serviceInfo = await configurationServiceProvider.provide(cliConfig);
+    const serviceInfo = await configurationServiceProvider.getServiceInfo(
+      cliConfig,
+    );
 
     await configurationServiceProvider.initService(context);
 
@@ -235,15 +241,21 @@ describe("ConfigurationServiceProvider tests", () => {
 
     configurationServiceProvider.setServiceKeyValueScope("service-id-2");
 
-    expect(keyValueService.hasKey("foo1")).toBeFalse();
+    expect(await keyValueService.hasKey("foo1")).toBeFalse();
 
     await configurationServiceProvider.clearKeyValueScope();
     configurationServiceProvider.setServiceKeyValueScope("service-id-1");
 
-    expect(keyValueService.getKey("foo1")).toEqual("bar");
+    expect(await keyValueService.getKey("foo1")).toEqual("bar");
 
     await configurationServiceProvider.clearKeyValueScope();
 
-    expect(() => keyValueService.hasKey("foo1")).toThrow();
+    expect(keyValueService.hasKey("foo1")).rejects.toThrow();
+  });
+
+  test("secretServiceEnabled requires configEnabled", () => {
+    expect(
+      () => new ConfigurationServiceProvider(100, false, false, false, true),
+    ).toThrow("configEnabled must be true");
   });
 });

package/tests/service/configuration/DefaultKeyValueService.test.ts

@@ -1,14 +1,23 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 import DefaultKeyValueService from "../../../src/service/configuration/DefaultKeyValueService.ts";
+import DefaultSecretService from "../../../src/service/configuration/DefaultSecretService.ts";
+
+function createMockSecretsApi() {
+  return {
+    get: mock(() => Promise.resolve(null as string | null)),
+    set: mock(() => Promise.resolve()),
+    delete: mock(() => Promise.resolve(true)),
+  };
+}
 
 describe("DefaultKeyValueService tests", () => {
-  test("Setting data works", () => {
+  test("Setting data works", async () => {
     const keyValueService = new DefaultKeyValueService();
 
     keyValueService.setKeyValueData(new Map([["foo", "bar"]]));
 
-    expect(keyValueService.hasKey("foo")).toBeTrue();
-    expect(keyValueService.getKey("foo")).toEqual("bar");
+    expect(await keyValueService.hasKey("foo")).toBeTrue();
+    expect(await keyValueService.getKey("foo")).toEqual("bar");
   });
 
   test("Cannot set data without clearing", () => {
@@ -21,23 +30,23 @@ describe("DefaultKeyValueService tests", () => {
     keyValueService.setKeyValueData(new Map());
   });
 
-  test("Cannot modify data before setting it", () => {
+  test("Cannot modify data before setting it", async () => {
     const keyValueService = new DefaultKeyValueService();
 
-    expect(() => keyValueService.setKey("foo", "bar")).toThrow();
-    expect(() => keyValueService.hasKey("foo")).toThrow();
-    expect(() => keyValueService.getKey("foo")).toThrow();
-    expect(() => keyValueService.deleteKey("foo")).toThrow();
+    expect(keyValueService.setKey("foo", "bar")).rejects.toThrow();
+    expect(keyValueService.hasKey("foo")).rejects.toThrow();
+    expect(keyValueService.getKey("foo")).rejects.toThrow();
+    expect(keyValueService.deleteKey("foo")).rejects.toThrow();
 
     keyValueService.setKeyValueData(new Map());
 
-    keyValueService.setKey("foo", "bar");
-    expect(keyValueService.hasKey("foo")).toBeTrue();
-    expect(keyValueService.getKey("foo")).toEqual("bar");
-    keyValueService.deleteKey("foo");
+    await keyValueService.setKey("foo", "bar");
+    expect(await keyValueService.hasKey("foo")).toBeTrue();
+    expect(await keyValueService.getKey("foo")).toEqual("bar");
+    await keyValueService.deleteKey("foo");
   });
 
-  test("Dirty state is managed correctly", () => {
+  test("Dirty state is managed correctly", async () => {
     const keyValueService = new DefaultKeyValueService();
 
     expect(keyValueService.isDirty()).toBeFalse();
@@ -46,7 +55,7 @@ describe("DefaultKeyValueService tests", () => {
 
     expect(keyValueService.isDirty()).toBeFalse();
 
-    keyValueService.setKey("foo", "bar");
+    await keyValueService.setKey("foo", "bar");
 
     expect(keyValueService.isDirty()).toBeTrue();
 
@@ -58,8 +67,101 @@ describe("DefaultKeyValueService tests", () => {
 
     expect(keyValueService.isDirty()).toBeFalse();
 
-    keyValueService.deleteKey("foo");
+    await keyValueService.deleteKey("foo");
+
+    expect(keyValueService.isDirty()).toBeTrue();
+  });
+
+  test("setKey with isSecret=true throws without secret service", async () => {
+    const keyValueService = new DefaultKeyValueService();
+    keyValueService.setKeyValueData(new Map());
+
+    await expect(
+      keyValueService.setKey("token", "secret", true),
+    ).rejects.toThrow("no secret service");
+  });
+
+  test("setKey with isSecret=true stores sentinel", async () => {
+    const mockApi = createMockSecretsApi();
+    const secretService = new DefaultSecretService("test-cli", mockApi);
+    secretService.setScope("command_test");
+    const keyValueService = new DefaultKeyValueService(secretService);
+    keyValueService.setKeyValueData(new Map());
+
+    await keyValueService.setKey("token", "my-secret", true);
+
+    expect(await keyValueService.hasKey("token")).toBeTrue();
+    expect(keyValueService.isDirty()).toBeTrue();
+    expect(mockApi.set).toHaveBeenCalledTimes(1);
+  });
+
+  test("getKey resolves secret sentinel", async () => {
+    const mockApi = createMockSecretsApi();
+    const secretService = new DefaultSecretService("test-cli", mockApi);
+    secretService.setScope("command_test");
+    const keyValueService = new DefaultKeyValueService(secretService);
+    keyValueService.setKeyValueData(
+      new Map([["token", "__SECRET__:command_test_token"]]),
+    );
+
+    mockApi.get.mockResolvedValueOnce("resolved-secret");
+    const value = await keyValueService.getKey("token");
+    expect(value).toEqual("resolved-secret");
+    expect(mockApi.get).toHaveBeenCalledWith({
+      service: "test_cli",
+      name: "command_test_token",
+    });
+  });
+
+  test("getKey throws when secret not found in OS store", async () => {
+    const mockApi = createMockSecretsApi();
+    const secretService = new DefaultSecretService("test-cli", mockApi);
+    secretService.setScope("command_test");
+    const keyValueService = new DefaultKeyValueService(secretService);
+    keyValueService.setKeyValueData(
+      new Map([["token", "__SECRET__:command_test_token"]]),
+    );
+
+    mockApi.get.mockResolvedValueOnce(null);
+    await expect(keyValueService.getKey("token")).rejects.toThrow(
+      "Secret not found",
+    );
+  });
+
+  test("getKey with sentinel throws without secret service", async () => {
+    const keyValueService = new DefaultKeyValueService();
+    keyValueService.setKeyValueData(
+      new Map([["token", "__SECRET__:command_test_token"]]),
+    );
+
+    await expect(keyValueService.getKey("token")).rejects.toThrow(
+      "no secret service",
+    );
+  });
 
+  test("deleteKey removes secret from OS store", async () => {
+    const mockApi = createMockSecretsApi();
+    const secretService = new DefaultSecretService("test-cli", mockApi);
+    secretService.setScope("command_test");
+    const keyValueService = new DefaultKeyValueService(secretService);
+    keyValueService.setKeyValueData(
+      new Map([["token", "__SECRET__:command_test_token"]]),
+    );
+
+    await keyValueService.deleteKey("token");
+    expect(mockApi.delete).toHaveBeenCalledWith({
+      service: "test_cli",
+      name: "command_test_token",
+    });
+    expect(await keyValueService.hasKey("token")).toBeFalse();
     expect(keyValueService.isDirty()).toBeTrue();
   });
+
+  test("deleteKey works for non-secret values", async () => {
+    const keyValueService = new DefaultKeyValueService();
+    keyValueService.setKeyValueData(new Map([["foo", "bar"]]));
+
+    await keyValueService.deleteKey("foo");
+    expect(await keyValueService.hasKey("foo")).toBeFalse();
+  });
 });

package/tests/service/configuration/DefaultSecretService.test.ts

@@ -0,0 +1,148 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import DefaultSecretService from "../../../src/service/configuration/DefaultSecretService.ts";
+
+function createMockSecretsApi() {
+  return {
+    get: mock(() => Promise.resolve(null as string | null)),
+    set: mock(() => Promise.resolve()),
+    delete: mock(() => Promise.resolve(true)),
+  };
+}
+
+describe("DefaultSecretService tests", () => {
+  let service: DefaultSecretService;
+  let mockApi: ReturnType<typeof createMockSecretsApi>;
+
+  beforeEach(() => {
+    mockApi = createMockSecretsApi();
+    service = new DefaultSecretService("my-test-cli", mockApi);
+  });
+
+  afterEach(() => {
+    service.clearScope();
+  });
+
+  test("Constructor sanitizes service name", async () => {
+    const api = createMockSecretsApi();
+    const s = new DefaultSecretService("my-cool-cli!", api);
+    s.setScope("command_test");
+    await s.setSecret("key", "value");
+    expect(api.set).toHaveBeenCalledWith({
+      service: "my_cool_cli_",
+      name: "command_test_key",
+      value: "value",
+    });
+  });
+
+  test("Constructor throws if sanitized service name exceeds 255 chars", () => {
+    const api = createMockSecretsApi();
+    expect(() => new DefaultSecretService("a".repeat(256), api)).toThrow(
+      "exceeds 255 characters",
+    );
+  });
+
+  test("setSecret throws without scope", async () => {
+    await expect(service.setSecret("key", "value")).rejects.toThrow(
+      "without a scope",
+    );
+  });
+
+  test("setSecret constructs correct name and returns it", async () => {
+    service.setScope("command_mycommand");
+    const name = await service.setSecret("token", "secret123");
+    expect(name).toEqual("command_mycommand_token");
+    expect(mockApi.set).toHaveBeenCalledWith({
+      service: "my_test_cli",
+      name: "command_mycommand_token",
+      value: "secret123",
+    });
+  });
+
+  test("setSecret sanitizes scope and key", async () => {
+    service.setScope("command_my-cmd");
+    const name = await service.setSecret("my-key!", "value");
+    expect(name).toEqual("command_my_cmd_my_key_");
+    expect(mockApi.set).toHaveBeenCalledWith({
+      service: "my_test_cli",
+      name: "command_my_cmd_my_key_",
+      value: "value",
+    });
+  });
+
+  test("setSecret throws if name exceeds 255 chars", async () => {
+    service.setScope("command_test");
+    await expect(
+      service.setSecret("a".repeat(250), "value"),
+    ).rejects.toThrow("exceeds 255 characters");
+  });
+
+  test("setSecret throws if value exceeds 2047 bytes", async () => {
+    service.setScope("command_test");
+    await expect(
+      service.setSecret("key", "a".repeat(2048)),
+    ).rejects.toThrow("exceeds 2047 bytes");
+  });
+
+  test("getSecret delegates to secrets API", async () => {
+    mockApi.get.mockResolvedValueOnce("secret_value");
+    const result = await service.getSecret("command_test_key");
+    expect(result).toEqual("secret_value");
+    expect(mockApi.get).toHaveBeenCalledWith({
+      service: "my_test_cli",
+      name: "command_test_key",
+    });
+  });
+
+  test("getSecret returns null when not found", async () => {
+    mockApi.get.mockResolvedValueOnce(null);
+    const result = await service.getSecret("nonexistent");
+    expect(result).toBeNull();
+  });
+
+  test("deleteSecret delegates to secrets API", async () => {
+    mockApi.delete.mockResolvedValueOnce(true);
+    const result = await service.deleteSecret("command_test_key");
+    expect(result).toBeTrue();
+    expect(mockApi.delete).toHaveBeenCalledWith({
+      service: "my_test_cli",
+      name: "command_test_key",
+    });
+  });
+
+  test("deleteSecret returns false when not found", async () => {
+    mockApi.delete.mockResolvedValueOnce(false);
+    const result = await service.deleteSecret("nonexistent");
+    expect(result).toBeFalse();
+  });
+
+  test("hasSecret returns true when secret exists", async () => {
+    mockApi.get.mockResolvedValueOnce("some_value");
+    const result = await service.hasSecret("command_test_key");
+    expect(result).toBeTrue();
+  });
+
+  test("hasSecret returns false when secret does not exist", async () => {
+    mockApi.get.mockResolvedValueOnce(null);
+    const result = await service.hasSecret("nonexistent");
+    expect(result).toBeFalse();
+  });
+
+  test("clearScope resets scope", async () => {
+    service.setScope("command_test");
+    service.clearScope();
+    await expect(service.setSecret("key", "value")).rejects.toThrow(
+      "without a scope",
+    );
+  });
+
+  test("setScope updates scope for subsequent calls", async () => {
+    service.setScope("command_cmd1");
+    let name = await service.setSecret("key", "value1");
+    expect(name).toEqual("command_cmd1_key");
+
+    service.clearScope();
+    service.setScope("service_svc1");
+    name = await service.setSecret("key", "value2");
+    expect(name).toEqual("service_svc1_key");
+  });
+});