@flowscripter/dynamic-cli-framework 1.4.19 → 1.6.0

package/tests/service/prompter/DefaultPrompterService.test.ts

@@ -1,598 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import DefaultPrompterService, {
-  DEFAULT_PROMPTER_CONFIG,
-} from "../../../src/service/prompter/DefaultPrompterService.ts";
-import type KeyReader from "../../../src/terminal/KeyReader.ts";
-import { type KeyEvent, SpecialKey } from "../../../src/terminal/KeyReader.ts";
-import type Terminal from "../../../src/terminal/Terminal.ts";
-import { PromptType } from "../../../src/api/service/core/PrompterService.ts";
-import type PrinterService from "../../../src/api/service/core/PrinterService.ts";
-
-class MockKeyReader implements KeyReader {
-  #keys: KeyEvent[] = [];
-
-  enableRawMode() {}
-  disableRawMode() {}
-
-  addKeys(...keys: KeyEvent[]) {
-    this.#keys.push(...keys);
-  }
-
-  readKey(): Promise<KeyEvent> {
-    const key = this.#keys.shift();
-    if (!key) throw new Error("No more keys");
-    return Promise.resolve(key);
-  }
-}
-
-class MockTerminal implements Terminal {
-  buffer = "";
-  clearUpLinesCalls: number[] = [];
-  hideCursorCalled = false;
-  showCursorCalled = false;
-
-  clearLine(): Promise<void> {
-    return Promise.resolve();
-  }
-
-  clearUpLines(count: number): Promise<void> {
-    this.clearUpLinesCalls.push(count);
-    return Promise.resolve();
-  }
-
-  hideCursor(): Promise<void> {
-    this.hideCursorCalled = true;
-    return Promise.resolve();
-  }
-
-  showCursor(): Promise<void> {
-    this.showCursorCalled = true;
-    return Promise.resolve();
-  }
-
-  write(text: string): Promise<void> {
-    this.buffer += text;
-    return Promise.resolve();
-  }
-
-  columns(): number {
-    return 80;
-  }
-
-  rows(): number {
-    return 24;
-  }
-}
-
-function getMockPrinterService(): PrinterService {
-  return {
-    colorEnabled: false,
-    hyperlinksEnabled: false,
-    darkMode: false,
-    stdoutWritable: new WritableStream(),
-    stderrWritable: new WritableStream(),
-    primary: (m: string) => m,
-    secondary: (m: string) => m,
-    emphasised: (m: string) => m,
-    selected: (m: string) => m,
-    italic: (m: string) => m,
-    yellow: (m: string) => m,
-    orange: (m: string) => m,
-    red: (m: string) => m,
-    magenta: (m: string) => m,
-    violet: (m: string) => m,
-    blue: (m: string) => m,
-    cyan: (m: string) => m,
-    green: (m: string) => m,
-    color: (m: string, _c: string) => m,
-    backgroundPrimary: (m: string) => m,
-    backgroundSecondary: (m: string) => m,
-    backgroundEmphasised: (m: string) => m,
-    backgroundSelected: (m: string) => m,
-    backgroundYellow: (m: string) => m,
-    backgroundOrange: (m: string) => m,
-    backgroundRed: (m: string) => m,
-    backgroundMagenta: (m: string) => m,
-    backgroundViolet: (m: string) => m,
-    backgroundBlue: (m: string) => m,
-    backgroundCyan: (m: string) => m,
-    backgroundGreen: (m: string) => m,
-    backgroundColor: (m: string, _c: string) => m,
-    hyperlink: (t: string, _u: string) => t,
-    stdoutColumns: () => 80,
-    stderrColumns: () => 80,
-    print: () => Promise.resolve(),
-    debug: () => Promise.resolve(),
-    info: () => Promise.resolve(),
-    warn: () => Promise.resolve(),
-    error: () => Promise.resolve(),
-    setLevel: () => {},
-    getLevel: () => 1,
-    showSpinner: () => Promise.resolve(),
-    hideSpinner: () => Promise.resolve(),
-    showProgressBar: () => Promise.resolve(0),
-    hideProgressBar: () => Promise.resolve(),
-    hideAllProgressBars: () => Promise.resolve(),
-    updateProgressBar: () => {},
-  } as PrinterService;
-}
-
-function createService(
-  keyReader: MockKeyReader,
-  configOverrides?: Partial<
-    import("../../../src/service/prompter/DefaultPrompterService.ts").PrompterServiceConfig
-  >,
-): {
-  service: DefaultPrompterService;
-  terminal: MockTerminal;
-} {
-  const terminal = new MockTerminal();
-  const config = { ...DEFAULT_PROMPTER_CONFIG, ...configOverrides };
-  const service = new DefaultPrompterService(config, terminal, keyReader, getMockPrinterService());
-  return { service, terminal };
-}
-
-const SSH_ENV_KEYS = ["SSH_CONNECTION", "SSH_CLIENT", "SSH_TTY"] as const;
-
-function withSshEnvOverride<T>(overrides: Record<string, string | undefined>, fn: () => T): T {
-  const saved = SSH_ENV_KEYS.map((k) => process.env[k]);
-  SSH_ENV_KEYS.forEach((k) => {
-    if (k in overrides) {
-      if (overrides[k] === undefined) delete process.env[k];
-      else process.env[k] = overrides[k];
-    } else {
-      delete process.env[k];
-    }
-  });
-  try {
-    return fn();
-  } finally {
-    SSH_ENV_KEYS.forEach((k, i) => {
-      if (saved[i] === undefined) delete process.env[k];
-      else process.env[k] = saved[i];
-    });
-  }
-}
-
-function withoutSshEnv<T>(fn: () => T): T {
-  return withSshEnvOverride({}, fn);
-}
-
-describe("DefaultPrompterService tests", () => {
-  test("SINGLE_SELECT selects correct option", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys(
-      { specialKey: SpecialKey.DOWN },
-      {
-        specialKey: SpecialKey.ENTER,
-      },
-    );
-    const { service } = createService(keyReader);
-
-    const result = await service.prompt({
-      name: "test",
-      promptText: "Pick one",
-      type: PromptType.SINGLE_SELECT,
-      options: [
-        { displayValue: "Option A", returnedValue: "a" },
-        { displayValue: "Option B", returnedValue: "b" },
-        { displayValue: "Option C", returnedValue: "c" },
-      ],
-    });
-
-    expect(result.name).toEqual("test");
-    expect(result.value).toEqual("b");
-  });
-
-  test("MULTI_SELECT selects correct options", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys(
-      { specialKey: SpecialKey.SPACE },
-      { specialKey: SpecialKey.DOWN },
-      { specialKey: SpecialKey.SPACE },
-      { specialKey: SpecialKey.ENTER },
-    );
-    const { service } = createService(keyReader);
-
-    const result = await service.prompt({
-      name: "test",
-      promptText: "Pick many",
-      type: PromptType.MULTI_SELECT,
-      options: [
-        { displayValue: "Option A", returnedValue: "a" },
-        { displayValue: "Option B", returnedValue: "b" },
-        { displayValue: "Option C", returnedValue: "c" },
-      ],
-    });
-
-    expect(result.name).toEqual("test");
-    expect(result.value).toEqual(["a", "b"]);
-  });
-
-  test("ACKNOWLEDGE selects Yes when navigated to", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys(
-      { specialKey: SpecialKey.UP },
-      {
-        specialKey: SpecialKey.ENTER,
-      },
-    );
-    const { service } = createService(keyReader);
-
-    const result = await service.prompt({
-      name: "test",
-      promptText: "Confirm?",
-      type: PromptType.ACKNOWLEDGE,
-      options: [],
-    });
-
-    expect(result.name).toEqual("test");
-    expect(result.value).toEqual(true);
-  });
-
-  test("TOGGLE selects False", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys(
-      { specialKey: SpecialKey.DOWN },
-      {
-        specialKey: SpecialKey.ENTER,
-      },
-    );
-    const { service } = createService(keyReader);
-
-    const result = await service.prompt({
-      name: "test",
-      promptText: "Toggle?",
-      type: PromptType.TOGGLE,
-      options: [],
-    });
-
-    expect(result.name).toEqual("test");
-    expect(result.value).toEqual(false);
-  });
-
-  test("TEXT captures typed characters", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys(
-      { key: "h" },
-      { key: "i" },
-      {
-        specialKey: SpecialKey.ENTER,
-      },
-    );
-    const { service } = createService(keyReader);
-
-    const result = await service.prompt({
-      name: "test",
-      promptText: "Enter text",
-      type: PromptType.TEXT,
-      options: [],
-    });
-
-    expect(result.name).toEqual("test");
-    expect(result.value).toEqual("hi");
-  });
-
-  test("TEXT handles backspace", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys(
-      { key: "h" },
-      { key: "i" },
-      { specialKey: SpecialKey.BACKSPACE },
-      { key: "o" },
-      { specialKey: SpecialKey.ENTER },
-    );
-    const { service } = createService(keyReader);
-
-    const result = await service.prompt({
-      name: "test",
-      promptText: "Enter text",
-      type: PromptType.TEXT,
-      options: [],
-    });
-
-    expect(result.name).toEqual("test");
-    expect(result.value).toEqual("ho");
-  });
-
-  test("promptEnabled=false with default returns default value", async () => {
-    const keyReader = new MockKeyReader();
-    const { service } = createService(keyReader);
-    service.promptEnabled = false;
-
-    const result = await service.prompt({
-      name: "test",
-      promptText: "Pick one",
-      type: PromptType.SINGLE_SELECT,
-      defaultOption: { displayValue: "Default", returnedValue: "default_val" },
-      options: [
-        { displayValue: "Default", returnedValue: "default_val" },
-        { displayValue: "Other", returnedValue: "other" },
-      ],
-    });
-
-    expect(result.name).toEqual("test");
-    expect(result.value).toEqual("default_val");
-  });
-
-  test("promptEnabled=false without default throws error", async () => {
-    const keyReader = new MockKeyReader();
-    const { service } = createService(keyReader);
-    service.promptEnabled = false;
-
-    await expect(
-      service.prompt({
-        name: "test",
-        promptText: "Pick one",
-        type: PromptType.SINGLE_SELECT,
-        options: [{ displayValue: "A", returnedValue: "a" }],
-      }),
-    ).rejects.toThrow("Prompting is disabled and no default for prompt: test");
-  });
-
-  test("ESCAPE cancels prompt", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys({ specialKey: SpecialKey.ESCAPE });
-    const { service } = createService(keyReader);
-
-    await expect(
-      service.prompt({
-        name: "test",
-        promptText: "Pick one",
-        type: PromptType.SINGLE_SELECT,
-        options: [{ displayValue: "A", returnedValue: "a" }],
-      }),
-    ).rejects.toThrow("Prompt cancelled");
-  });
-
-  test("promptAll runs multiple prompts sequentially", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys(
-      { specialKey: SpecialKey.ENTER },
-      { key: "x" },
-      { specialKey: SpecialKey.ENTER },
-    );
-    const { service } = createService(keyReader);
-
-    const results = await service.promptAll([
-      {
-        name: "first",
-        promptText: "Pick one",
-        type: PromptType.SINGLE_SELECT,
-        options: [
-          { displayValue: "A", returnedValue: "a" },
-          { displayValue: "B", returnedValue: "b" },
-        ],
-      },
-      {
-        name: "second",
-        promptText: "Enter text",
-        type: PromptType.TEXT,
-        options: [],
-      },
-    ]);
-
-    expect(results.length).toEqual(2);
-    expect(results[0]!.name).toEqual("first");
-    expect(results[0]!.value).toEqual("a");
-    expect(results[1]!.name).toEqual("second");
-    expect(results[1]!.value).toEqual("x");
-  });
-
-  test("OPEN_URL calls openUrl and returns URL on ENTER", () =>
-    withoutSshEnv(async () => {
-      const keyReader = new MockKeyReader();
-      keyReader.addKeys({ specialKey: SpecialKey.ENTER });
-      let openedUrl: string | undefined;
-      const mockOpenUrl = (url: string): Promise<void> => {
-        openedUrl = url;
-        return Promise.resolve();
-      };
-      const { service } = createService(keyReader, { openUrl: mockOpenUrl });
-
-      const result = await service.prompt({
-        name: "login",
-        promptText: "Login at:",
-        type: PromptType.OPEN_URL,
-        options: [
-          {
-            displayValue: "Open browser to login",
-            returnedValue: "https://example.com/login",
-          },
-        ],
-      });
-
-      expect(result.name).toEqual("login");
-      expect(result.value).toEqual("https://example.com/login");
-      expect(openedUrl).toEqual("https://example.com/login");
-    }));
-
-  test("OPEN_URL ESCAPE cancels without calling openUrl", async () => {
-    const keyReader = new MockKeyReader();
-    keyReader.addKeys({ specialKey: SpecialKey.ESCAPE });
-    let openUrlCalled = false;
-    const mockOpenUrl = (_url: string): Promise<void> => {
-      openUrlCalled = true;
-      return Promise.resolve();
-    };
-    const { service } = createService(keyReader, { openUrl: mockOpenUrl });
-
-    await expect(
-      service.prompt({
-        name: "login",
-        promptText: "Login at:",
-        type: PromptType.OPEN_URL,
-        options: [
-          {
-            displayValue: "Open browser",
-            returnedValue: "https://example.com/login",
-          },
-        ],
-      }),
-    ).rejects.toThrow("Prompt cancelled");
-    expect(openUrlCalled).toBe(false);
-  });
-
-  test("OPEN_URL renders header, URL, and instruction", () =>
-    withoutSshEnv(async () => {
-      const keyReader = new MockKeyReader();
-      keyReader.addKeys({ specialKey: SpecialKey.ENTER });
-      const mockOpenUrl = (_url: string): Promise<void> => Promise.resolve();
-      const { service, terminal } = createService(keyReader, {
-        openUrl: mockOpenUrl,
-      });
-
-      await service.prompt({
-        name: "login",
-        promptText: "Login at:",
-        type: PromptType.OPEN_URL,
-        options: [
-          {
-            displayValue: "Open browser to login",
-            returnedValue: "https://example.com/login",
-          },
-        ],
-      });
-
-      expect(terminal.buffer).toContain("Login at:");
-      expect(terminal.buffer).toContain("https://example.com/login");
-      expect(terminal.buffer).toContain("Press ENTER to open in the browser...");
-      expect(terminal.buffer).toContain("Open browser to login");
-    }));
-
-  test("OPEN_URL handles openUrl failure gracefully", () =>
-    withoutSshEnv(async () => {
-      const keyReader = new MockKeyReader();
-      keyReader.addKeys({ specialKey: SpecialKey.ENTER });
-      const mockOpenUrl = (_url: string): Promise<void> => {
-        return Promise.reject(new Error("browser not found"));
-      };
-      const { service, terminal } = createService(keyReader, {
-        openUrl: mockOpenUrl,
-      });
-
-      const result = await service.prompt({
-        name: "login",
-        promptText: "Login at:",
-        type: PromptType.OPEN_URL,
-        options: [
-          {
-            displayValue: "Open browser",
-            returnedValue: "https://example.com/login",
-          },
-        ],
-      });
-
-      expect(result.name).toEqual("login");
-      expect(result.value).toEqual("https://example.com/login");
-      expect(terminal.buffer).toContain("Failed to open URL: browser not found");
-    }));
-
-  test("OPEN_URL with promptEnabled=false and defaultOption returns default", async () => {
-    const keyReader = new MockKeyReader();
-    const { service } = createService(keyReader);
-    service.promptEnabled = false;
-
-    const result = await service.prompt({
-      name: "login",
-      promptText: "Login at:",
-      type: PromptType.OPEN_URL,
-      defaultOption: {
-        displayValue: "Default URL",
-        returnedValue: "https://example.com/default",
-      },
-      options: [
-        {
-          displayValue: "Open browser",
-          returnedValue: "https://example.com/login",
-        },
-      ],
-    });
-
-    expect(result.name).toEqual("login");
-    expect(result.value).toEqual("https://example.com/default");
-  });
-
-  test("OPEN_URL with promptEnabled=false and no defaultOption throws", async () => {
-    const keyReader = new MockKeyReader();
-    const { service } = createService(keyReader);
-    service.promptEnabled = false;
-
-    await expect(
-      service.prompt({
-        name: "login",
-        promptText: "Login at:",
-        type: PromptType.OPEN_URL,
-        options: [
-          {
-            displayValue: "Open browser",
-            returnedValue: "https://example.com/login",
-          },
-        ],
-      }),
-    ).rejects.toThrow("Prompting is disabled and no default for prompt: login");
-  });
-
-  test("OPEN_URL in SSH session shows copy message and skips openUrl", () =>
-    withSshEnvOverride({ SSH_CONNECTION: "192.168.1.1 12345 192.168.1.2 22" }, async () => {
-      const keyReader = new MockKeyReader();
-      keyReader.addKeys({ specialKey: SpecialKey.ENTER });
-      let openUrlCalled = false;
-      const mockOpenUrl = (_url: string): Promise<void> => {
-        openUrlCalled = true;
-        return Promise.resolve();
-      };
-      const { service, terminal } = createService(keyReader, {
-        openUrl: mockOpenUrl,
-      });
-
-      const result = await service.prompt({
-        name: "login",
-        promptText: "Login at:",
-        type: PromptType.OPEN_URL,
-        options: [
-          {
-            displayValue: "Open browser",
-            returnedValue: "https://example.com/login",
-          },
-        ],
-      });
-
-      expect(result.name).toEqual("login");
-      expect(result.value).toEqual("https://example.com/login");
-      expect(openUrlCalled).toBe(false);
-      expect(terminal.buffer).toContain(
-        "Copy the URL above and open it in your local browser, then press ENTER to continue...",
-      );
-      expect(terminal.buffer).not.toContain("Press ENTER to open in the browser...");
-    }));
-
-  test("OPEN_URL outside SSH session shows open message", () =>
-    withoutSshEnv(async () => {
-      const keyReader = new MockKeyReader();
-      keyReader.addKeys({ specialKey: SpecialKey.ENTER });
-      let openUrlCalled = false;
-      const mockOpenUrl = (_url: string): Promise<void> => {
-        openUrlCalled = true;
-        return Promise.resolve();
-      };
-      const { service, terminal } = createService(keyReader, {
-        openUrl: mockOpenUrl,
-      });
-
-      await service.prompt({
-        name: "login",
-        promptText: "Login at:",
-        type: PromptType.OPEN_URL,
-        options: [
-          {
-            displayValue: "Open browser",
-            returnedValue: "https://example.com/login",
-          },
-        ],
-      });
-
-      expect(openUrlCalled).toBe(true);
-      expect(terminal.buffer).toContain("Press ENTER to open in the browser...");
-    }));
-});

package/tests/service/prompter/PrompterServiceProvider.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import PrompterServiceProvider from "../../../src/service/prompter/PrompterServiceProvider.ts";
-import { PROMPTER_SERVICE_ID } from "../../../src/api/service/core/PrompterService.ts";
-import type PrompterService from "../../../src/api/service/core/PrompterService.ts";
-import DefaultContext from "../../../src/runtime/DefaultContext.ts";
-import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
-
-function getMockPrompterService(): PrompterService {
-  return {
-    promptEnabled: true,
-    prompt: () => Promise.resolve({ name: "", value: "" }),
-    promptAll: () => Promise.resolve([]),
-  };
-}
-
-describe("PrompterServiceProvider tests", () => {
-  test("PrompterServiceProvider has correct serviceId", () => {
-    const provider = new PrompterServiceProvider(100, getMockPrompterService());
-
-    expect(provider.serviceId).toEqual(PROMPTER_SERVICE_ID);
-  });
-
-  test("PrompterServiceProvider getServiceInfo returns service and one command", async () => {
-    const prompterService = getMockPrompterService();
-    const provider = new PrompterServiceProvider(100, prompterService);
-    const cliConfig = getCLIConfig();
-
-    const serviceInfo = await provider.getServiceInfo(cliConfig);
-
-    expect(serviceInfo.service).toBe(prompterService);
-    expect(serviceInfo.commands.length).toEqual(1);
-    expect(serviceInfo.commands[0]!.name).toEqual("no-prompt");
-  });
-
-  test("PrompterServiceProvider initService resolves", async () => {
-    const provider = new PrompterServiceProvider(100, getMockPrompterService());
-    const context = new DefaultContext(getCLIConfig());
-
-    await expect(provider.initService(context)).resolves.toBeUndefined();
-  });
-});

package/tests/service/prompter/command/NoPromptCommand.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import NoPromptCommand from "../../../../src/service/prompter/command/NoPromptCommand.ts";
-import PrompterServiceProvider from "../../../../src/service/prompter/PrompterServiceProvider.ts";
-import { ArgumentValueTypeName } from "../../../../src/api/argument/ArgumentValueTypes.ts";
-import type PrompterService from "../../../../src/api/service/core/PrompterService.ts";
-import type Context from "../../../../src/api/Context.ts";
-
-function getMockPrompterService(): PrompterService {
-  return {
-    promptEnabled: true,
-    prompt: () => Promise.resolve({ name: "", value: "" }),
-    promptAll: () => Promise.resolve([]),
-  };
-}
-
-describe("NoPromptCommand tests", () => {
-  test("NoPromptCommand has correct properties", () => {
-    const prompterService = getMockPrompterService();
-    const provider = new PrompterServiceProvider(100, prompterService);
-    const command = new NoPromptCommand(provider, 100);
-
-    expect(command.name).toEqual("no-prompt");
-    expect(command.description).toEqual("Disable interactive prompting");
-    expect(command.enableConfiguration).toBeTrue();
-    expect(command.executePriority).toEqual(100);
-  });
-
-  test("NoPromptCommand has correct argument", () => {
-    const prompterService = getMockPrompterService();
-    const provider = new PrompterServiceProvider(100, prompterService);
-    const command = new NoPromptCommand(provider, 100);
-
-    expect(command.argument.type).toEqual(ArgumentValueTypeName.BOOLEAN);
-    expect(command.argument.defaultValue).toEqual(false);
-    expect(command.argument.configurationKey).toEqual("NO_PROMPT");
-  });
-
-  test("NoPromptCommand execute with true disables prompting", async () => {
-    const prompterService = getMockPrompterService();
-    const provider = new PrompterServiceProvider(100, prompterService);
-    const command = new NoPromptCommand(provider, 100);
-
-    await command.execute({} as Context, true);
-
-    expect(provider.prompterService.promptEnabled).toBeFalse();
-  });
-
-  test("NoPromptCommand execute with false enables prompting", async () => {
-    const prompterService = getMockPrompterService();
-    prompterService.promptEnabled = false;
-    const provider = new PrompterServiceProvider(100, prompterService);
-    const command = new NoPromptCommand(provider, 100);
-
-    await command.execute({} as Context, false);
-
-    expect(provider.prompterService.promptEnabled).toBeTrue();
-  });
-});