@flowscripter/dynamic-cli-framework 1.4.19 → 1.5.0

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

@@ -1,59 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,212 +0,0 @@
-import process from "node:process";
-import fs from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { describe, expect, test } from "bun:test";
-import ConfigurationServiceProvider from "../../../src/service/configuration/ConfigurationServiceProvider.ts";
-import DefaultContext from "../../../src/runtime/DefaultContext.ts";
-import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
-import { ArgumentValueTypeName } from "../../../src/api/argument/ArgumentValueTypes.ts";
-import type KeyValueService from "../../../src/api/service/core/KeyValueService.ts";
-import type SubCommand from "../../../src/api/command/SubCommand.ts";
-
-function getConfig() {
-  return {
-    defaults: {
-      command1: {
-        arg1: [1, 2],
-        arg2: {
-          arg3: "foo",
-        },
-      },
-      command2: {
-        arg4: true,
-      },
-    },
-    "key-values": {
-      commands: {
-        command1: {
-          foo1: "bar1",
-          foo2: "bar2",
-        },
-        command2: {
-          foo1: "bar3",
-        },
-      },
-      services: {
-        "service-id-1": {
-          foo1: "bar",
-        },
-        "service-id-2": {
-          foo2: "bar2",
-        },
-      },
-    },
-  };
-}
-
-function getSubCommand(): SubCommand {
-  return {
-    name: "command2",
-    enableConfiguration: true,
-    options: [
-      {
-        name: "arg4",
-        type: ArgumentValueTypeName.BOOLEAN,
-      },
-    ],
-    positionals: [],
-    execute: async (): Promise<void> => {},
-  };
-}
-describe("ConfigurationServiceProvider tests", () => {
-  test("ConfigurationServiceProvider getServiceInfo works", async () => {
-    const configurationServiceProvider = new ConfigurationServiceProvider(100, false, true);
-    const serviceInfo = await configurationServiceProvider.getServiceInfo(getCLIConfig());
-    expect(serviceInfo.commands.length).toEqual(2);
-  });
-
-  test("ConfigurationServiceProvider initService with no config works", async () => {
-    const configurationServiceProvider = new ConfigurationServiceProvider(100);
-
-    const context = new DefaultContext(getCLIConfig());
-
-    await configurationServiceProvider.initService(context);
-
-    expect(configurationServiceProvider.getConfigString()).toEqual("{}");
-  });
-
-  test("ConfigurationServiceProvider initService with config works", async () => {
-    const configurationServiceProvider = new ConfigurationServiceProvider(100, false, true);
-
-    const context = new DefaultContext(getCLIConfig());
-
-    const configFolder = await fs.mkdtemp(path.join(tmpdir(), "config-"));
-    const configLocation = path.join(configFolder, "config.json");
-    configurationServiceProvider.setConfigLocation(configLocation);
-
-    const config = getConfig();
-
-    await fs.writeFile(configLocation, JSON.stringify(config));
-
-    await configurationServiceProvider.initService(context);
-
-    expect(configurationServiceProvider.getConfigString()).toEqual(JSON.stringify(config, null, 2));
-  });
-
-  test("getDefaultArgumentValues works with config", async () => {
-    const configurationServiceProvider = new ConfigurationServiceProvider(100, false, true);
-
-    const context = new DefaultContext(getCLIConfig());
-
-    const configFolder = await fs.mkdtemp(path.join(tmpdir(), "config-"));
-    const configLocation = path.join(configFolder, "config.json");
-    configurationServiceProvider.setConfigLocation(configLocation);
-
-    const config = getConfig();
-
-    await fs.writeFile(configLocation, JSON.stringify(config));
-
-    const subCommand = getSubCommand();
-
-    await configurationServiceProvider.initService(context);
-    await configurationServiceProvider.getServiceInfo(getCLIConfig());
-
-    expect(
-      await configurationServiceProvider.getDefaultArgumentValues(getCLIConfig(), subCommand),
-    ).toEqual(config.defaults.command2);
-  });
-
-  test("getDefaultArgumentValues works with env vars", async () => {
-    try {
-      const configurationServiceProvider = new ConfigurationServiceProvider(100, true, true);
-
-      const context = new DefaultContext(getCLIConfig());
-
-      process.env["FOO_COMMAND2_ARG4"] = "true";
-
-      const subCommand = getSubCommand();
-
-      await configurationServiceProvider.initService(context);
-      await configurationServiceProvider.getServiceInfo(getCLIConfig());
-
-      expect(
-        await configurationServiceProvider.getDefaultArgumentValues(getCLIConfig(), subCommand),
-      ).toEqual({ arg4: "true" });
-    } finally {
-      delete process.env["FOO_COMMAND2_ARG4"];
-    }
-  });
-
-  test("setCommandKeyValueScope works", async () => {
-    const configurationServiceProvider = new ConfigurationServiceProvider(100, false, true, true);
-    const cliConfig = getCLIConfig();
-    const context = new DefaultContext(cliConfig);
-
-    const configFolder = await fs.mkdtemp(path.join(tmpdir(), "config-"));
-    const configLocation = path.join(configFolder, "config.json");
-    configurationServiceProvider.setConfigLocation(configLocation);
-
-    const config = getConfig();
-
-    await fs.writeFile(configLocation, JSON.stringify(config));
-
-    const serviceInfo = await configurationServiceProvider.getServiceInfo(cliConfig);
-
-    await configurationServiceProvider.initService(context);
-
-    const keyValueService = serviceInfo.service! as KeyValueService;
-
-    configurationServiceProvider.setCommandKeyValueScope("command2");
-
-    expect(await keyValueService.hasKey("foo2")).toBeFalse();
-
-    await configurationServiceProvider.clearKeyValueScope();
-    configurationServiceProvider.setCommandKeyValueScope("command1");
-
-    expect(await keyValueService.getKey("foo2")).toEqual("bar2");
-
-    await configurationServiceProvider.clearKeyValueScope();
-
-    expect(keyValueService.hasKey("foo2")).rejects.toThrow();
-  });
-
-  test("setServiceKeyValueScope works", async () => {
-    const configurationServiceProvider = new ConfigurationServiceProvider(100, false, true, true);
-    const cliConfig = getCLIConfig();
-    const context = new DefaultContext(cliConfig);
-
-    const configFolder = await fs.mkdtemp(path.join(tmpdir(), "config-"));
-    const configLocation = path.join(configFolder, "config.json");
-    configurationServiceProvider.setConfigLocation(configLocation);
-
-    const config = getConfig();
-
-    await fs.writeFile(configLocation, JSON.stringify(config));
-
-    const serviceInfo = await configurationServiceProvider.getServiceInfo(cliConfig);
-
-    await configurationServiceProvider.initService(context);
-
-    const keyValueService = serviceInfo.service! as KeyValueService;
-
-    configurationServiceProvider.setServiceKeyValueScope("service-id-2");
-
-    expect(await keyValueService.hasKey("foo1")).toBeFalse();
-
-    await configurationServiceProvider.clearKeyValueScope();
-    configurationServiceProvider.setServiceKeyValueScope("service-id-1");
-
-    expect(await keyValueService.getKey("foo1")).toEqual("bar");
-
-    await configurationServiceProvider.clearKeyValueScope();
-
-    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,155 +0,0 @@
-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", async () => {
-    const keyValueService = new DefaultKeyValueService();
-
-    keyValueService.setKeyValueData(new Map([["foo", "bar"]]));
-
-    expect(await keyValueService.hasKey("foo")).toBeTrue();
-    expect(await keyValueService.getKey("foo")).toEqual("bar");
-  });
-
-  test("Cannot set data without clearing", () => {
-    const keyValueService = new DefaultKeyValueService();
-
-    keyValueService.setKeyValueData(new Map());
-    expect(() => keyValueService.setKeyValueData(new Map())).toThrow();
-
-    keyValueService.clearKeyValueData();
-    keyValueService.setKeyValueData(new Map());
-  });
-
-  test("Cannot modify data before setting it", async () => {
-    const keyValueService = new DefaultKeyValueService();
-
-    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());
-
-    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", async () => {
-    const keyValueService = new DefaultKeyValueService();
-
-    expect(keyValueService.isDirty()).toBeFalse();
-
-    keyValueService.setKeyValueData(new Map());
-
-    expect(keyValueService.isDirty()).toBeFalse();
-
-    await keyValueService.setKey("foo", "bar");
-
-    expect(keyValueService.isDirty()).toBeTrue();
-
-    keyValueService.clearKeyValueData();
-
-    expect(keyValueService.isDirty()).toBeFalse();
-
-    keyValueService.setKeyValueData(new Map([["foo", "bar"]]));
-
-    expect(keyValueService.isDirty()).toBeFalse();
-
-    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

@@ -1,140 +0,0 @@
-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");
-  });
-});

package/tests/service/configuration/command/ConfigCommand.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import DefaultContext from "../../../../src/runtime/DefaultContext.ts";
-import ConfigCommand from "../../../../src/service/configuration/command/ConfigCommand.ts";
-import ConfigurationServiceProvider from "../../../../src/service/configuration/ConfigurationServiceProvider.ts";
-import { getCLIConfig } from "../../../fixtures/CLIConfig.ts";
-
-describe("ConfigCommand tests", () => {
-  test("has correct name and description", () => {
-    const configProvider = new ConfigurationServiceProvider(90, false, true);
-    const command = new ConfigCommand(configProvider, 90);
-
-    expect(command.name).toEqual("config");
-    expect(command.description).toEqual("Set the configuration file location");
-    expect(command.enableConfiguration).toEqual(true);
-    expect(command.executePriority).toEqual(90);
-  });
-
-  test("execute sets config location on the provider", async () => {
-    const configProvider = new ConfigurationServiceProvider(90, false, true);
-    const cliConfig = getCLIConfig();
-    const context = new DefaultContext(cliConfig);
-
-    const command = new ConfigCommand(configProvider, 90);
-
-    await command.execute(context, "/tmp/my-config.json");
-
-    expect(configProvider.configLocation).toEqual("/tmp/my-config.json");
-  });
-});