@flowscripter/dynamic-cli-framework 1.2.1 → 1.3.0

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

@@ -128,21 +128,13 @@ function createService(
 } {
   const terminal = new MockTerminal();
   const config = { ...DEFAULT_PROMPTER_CONFIG, ...configOverrides };
-  const service = new DefaultPrompterService(
-    config,
-    terminal,
-    keyReader,
-    getMockPrinterService(),
-  );
+  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 {
+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) {
@@ -171,7 +163,9 @@ describe("DefaultPrompterService tests", () => {
     const keyReader = new MockKeyReader();
     keyReader.addKeys(
       { specialKey: SpecialKey.DOWN },
-      { specialKey: SpecialKey.ENTER },
+      {
+        specialKey: SpecialKey.ENTER,
+      },
     );
     const { service } = createService(keyReader);
 
@@ -219,7 +213,9 @@ describe("DefaultPrompterService tests", () => {
     const keyReader = new MockKeyReader();
     keyReader.addKeys(
       { specialKey: SpecialKey.UP },
-      { specialKey: SpecialKey.ENTER },
+      {
+        specialKey: SpecialKey.ENTER,
+      },
     );
     const { service } = createService(keyReader);
 
@@ -238,7 +234,9 @@ describe("DefaultPrompterService tests", () => {
     const keyReader = new MockKeyReader();
     keyReader.addKeys(
       { specialKey: SpecialKey.DOWN },
-      { specialKey: SpecialKey.ENTER },
+      {
+        specialKey: SpecialKey.ENTER,
+      },
     );
     const { service } = createService(keyReader);
 
@@ -258,7 +256,9 @@ describe("DefaultPrompterService tests", () => {
     keyReader.addKeys(
       { key: "h" },
       { key: "i" },
-      { specialKey: SpecialKey.ENTER },
+      {
+        specialKey: SpecialKey.ENTER,
+      },
     );
     const { service } = createService(keyReader);
 
@@ -325,9 +325,7 @@ describe("DefaultPrompterService tests", () => {
         name: "test",
         promptText: "Pick one",
         type: PromptType.SINGLE_SELECT,
-        options: [
-          { displayValue: "A", returnedValue: "a" },
-        ],
+        options: [{ displayValue: "A", returnedValue: "a" }],
       }),
     ).rejects.toThrow("Prompting is disabled and no default for prompt: test");
   });
@@ -342,9 +340,7 @@ describe("DefaultPrompterService tests", () => {
         name: "test",
         promptText: "Pick one",
         type: PromptType.SINGLE_SELECT,
-        options: [
-          { displayValue: "A", returnedValue: "a" },
-        ],
+        options: [{ displayValue: "A", returnedValue: "a" }],
       }),
     ).rejects.toThrow("Prompt cancelled");
   });
@@ -460,9 +456,7 @@ describe("DefaultPrompterService tests", () => {
 
       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("Press ENTER to open in the browser...");
       expect(terminal.buffer).toContain("Open browser to login");
     }));
 
@@ -491,9 +485,7 @@ describe("DefaultPrompterService tests", () => {
 
       expect(result.name).toEqual("login");
       expect(result.value).toEqual("https://example.com/login");
-      expect(terminal.buffer).toContain(
-        "Failed to open URL: browser not found",
-      );
+      expect(terminal.buffer).toContain("Failed to open URL: browser not found");
     }));
 
   test("OPEN_URL with promptEnabled=false and defaultOption returns default", async () => {
@@ -538,49 +530,42 @@ describe("DefaultPrompterService tests", () => {
           },
         ],
       }),
-    ).rejects.toThrow(
-      "Prompting is disabled and no default for prompt: 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...",
-        );
-      },
-    ));
+    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 () => {
@@ -608,8 +593,6 @@ describe("DefaultPrompterService tests", () => {
       });
 
       expect(openUrlCalled).toBe(true);
-      expect(terminal.buffer).toContain(
-        "Press ENTER to open in the browser...",
-      );
+      expect(terminal.buffer).toContain("Press ENTER to open in the browser...");
     }));
 });

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

@@ -15,10 +15,7 @@ function getMockPrompterService(): PrompterService {
 
 describe("PrompterServiceProvider tests", () => {
   test("PrompterServiceProvider has correct serviceId", () => {
-    const provider = new PrompterServiceProvider(
-      100,
-      getMockPrompterService(),
-    );
+    const provider = new PrompterServiceProvider(100, getMockPrompterService());
 
     expect(provider.serviceId).toEqual(PROMPTER_SERVICE_ID);
   });
@@ -36,10 +33,7 @@ describe("PrompterServiceProvider tests", () => {
   });
 
   test("PrompterServiceProvider initService resolves", async () => {
-    const provider = new PrompterServiceProvider(
-      100,
-      getMockPrompterService(),
-    );
+    const provider = new PrompterServiceProvider(100, getMockPrompterService());
     const context = new DefaultContext(getCLIConfig());
 
     await expect(provider.initService(context)).resolves.toBeUndefined();

package/tests/service/shutdown/ShutdownServiceProvider.test.ts

@@ -5,9 +5,7 @@ import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
 describe("ShutdownServiceProvider tests", () => {
   test("ShutdownServiceProvider getServiceInfo works", async () => {
     const shutdownServiceProvider = new ShutdownServiceProvider(100);
-    const serviceInfo = await shutdownServiceProvider.getServiceInfo(
-      getCLIConfig(),
-    );
+    const serviceInfo = await shutdownServiceProvider.getServiceInfo(getCLIConfig());
     expect(serviceInfo.commands.length).toEqual(0);
 
     await ShutdownServiceProvider.shutdown();

package/tests/service/syntaxHighlighter/DefaultSyntaxHighlighterService.test.ts

@@ -17,57 +17,30 @@ describe("DefaultSyntaxHighlighterService tests", () => {
   test("Cannot register a syntax if already registered", () => {
     const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
 
-    expect(() => syntaxHighlighterService.registerSyntax("jSon", yaml))
-      .toThrow();
+    expect(() => syntaxHighlighterService.registerSyntax("jSon", yaml)).toThrow();
   });
 
   test("Can register new syntax", () => {
     const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
 
     syntaxHighlighterService.registerSyntax("yaml", yaml);
-    expect(syntaxHighlighterService.getRegisteredSyntaxes()).toEqual([
-      "json",
-      "yaml",
-    ]);
+    expect(syntaxHighlighterService.getRegisteredSyntaxes()).toEqual(["json", "yaml"]);
   });
 
   test("Cannot highlight with unknown syntax", () => {
     const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
 
-    expect(() => syntaxHighlighterService.highlight("foo: 1", "yaml"))
-      .toThrow();
+    expect(() => syntaxHighlighterService.highlight("foo: 1", "yaml")).toThrow();
   });
 
   test("Can highlight with JSON syntax", () => {
     const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
 
-    const highlighted = syntaxHighlighterService.highlight(
-      "{ foo: 1 }",
-      "json",
-    );
+    const highlighted = syntaxHighlighterService.highlight("{ foo: 1 }", "json");
     expectBytesEquals(
       highlighted,
       new Uint8Array([
-        123,
-        32,
-        102,
-        111,
-        111,
-        58,
-        32,
-        27,
-        91,
-        51,
-        54,
-        109,
-        49,
-        27,
-        91,
-        51,
-        57,
-        109,
-        32,
-        125,
+        123, 32, 102, 111, 111, 58, 32, 27, 91, 51, 54, 109, 49, 27, 91, 51, 57, 109, 32, 125,
       ]),
     );
   });
@@ -90,46 +63,14 @@ describe("DefaultSyntaxHighlighterService tests", () => {
 
     syntaxHighlighterService.colorFunction = printer.color.bind(printer);
 
-    const highlighted = syntaxHighlighterService.highlight(
-      "{ foo: 1 }",
-      "json",
-      {
-        "number": "#FF0000",
-      },
-    );
+    const highlighted = syntaxHighlighterService.highlight("{ foo: 1 }", "json", {
+      number: "#FF0000",
+    });
     expectBytesEquals(
       highlighted,
       new Uint8Array([
-        123,
-        32,
-        102,
-        111,
-        111,
-        58,
-        32,
-        27,
-        91,
-        51,
-        56,
-        59,
-        50,
-        59,
-        50,
-        53,
-        53,
-        59,
-        48,
-        59,
-        48,
-        109,
-        49,
-        27,
-        91,
-        51,
-        57,
-        109,
-        32,
-        125,
+        123, 32, 102, 111, 111, 58, 32, 27, 91, 51, 56, 59, 50, 59, 50, 53, 53, 59, 48, 59, 48, 109,
+        49, 27, 91, 51, 57, 109, 32, 125,
       ]),
     );
   });
@@ -143,32 +84,8 @@ describe("DefaultSyntaxHighlighterService tests", () => {
     expectBytesEquals(
       highlighted,
       new Uint8Array([
-        27,
-        91,
-        51,
-        51,
-        109,
-        102,
-        111,
-        111,
-        58,
-        27,
-        91,
-        51,
-        57,
-        109,
-        32,
-        27,
-        91,
-        51,
-        54,
-        109,
-        49,
-        27,
-        91,
-        51,
-        57,
-        109,
+        27, 91, 51, 51, 109, 102, 111, 111, 58, 27, 91, 51, 57, 109, 32, 27, 91, 51, 54, 109, 49,
+        27, 91, 51, 57, 109,
       ]),
     );
   });
@@ -177,10 +94,7 @@ describe("DefaultSyntaxHighlighterService tests", () => {
     const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
     syntaxHighlighterService.colorEnabled = false;
 
-    const highlighted = syntaxHighlighterService.highlight(
-      "{ foo: 1 }",
-      "json",
-    );
+    const highlighted = syntaxHighlighterService.highlight("{ foo: 1 }", "json");
 
     expect(highlighted).toEqual("{ foo: 1 }");
   });

package/tests/service/syntaxHighlighter/SyntaxHighlighterServiceProvider.test.ts

@@ -12,10 +12,7 @@ describe("SyntaxHighlighterServiceProvider tests", () => {
   test("SyntaxHighlighterServiceProvider getServiceInfo and initService works", async () => {
     const dummyStdout = new StreamString();
     const dummyStderr = new StreamString();
-    const syntaxHighlighterServiceProvider =
-      new SyntaxHighlighterServiceProvider(
-        100,
-      );
+    const syntaxHighlighterServiceProvider = new SyntaxHighlighterServiceProvider(100);
     const cliConfig = getCLIConfig();
     const context = new DefaultContext(cliConfig);
 
@@ -32,9 +29,7 @@ describe("SyntaxHighlighterServiceProvider tests", () => {
       ),
     );
 
-    const serviceInfo = await syntaxHighlighterServiceProvider.getServiceInfo(
-      cliConfig,
-    );
+    const serviceInfo = await syntaxHighlighterServiceProvider.getServiceInfo(cliConfig);
     expect(serviceInfo.commands.length).toEqual(0);
 
     await syntaxHighlighterServiceProvider.initService(context);

package/tests/service/tableGenerator/DefaultTableGeneratorService.test.ts

@@ -136,9 +136,7 @@ describe("DefaultTableGeneratorService tests", () => {
 
     const result = service.render(table);
     const lines = result.split("\n");
-    const contentLines = lines.filter((l) =>
-      l.startsWith("│") && !l.includes("─")
-    );
+    const contentLines = lines.filter((l) => l.startsWith("│") && !l.includes("─"));
     expect(contentLines.length).toBeGreaterThan(1);
     // Each content line should have complete words (no mid-word breaks)
     for (const line of contentLines) {
@@ -146,9 +144,7 @@ describe("DefaultTableGeneratorService tests", () => {
       if (content.length > 0) {
         const words = content.split(/\s+/);
         for (const word of words) {
-          expect(
-            ["hello", "world", "foo", "bar", ""].includes(word),
-          ).toBe(true);
+          expect(["hello", "world", "foo", "bar", ""].includes(word)).toBe(true);
         }
       }
     }
@@ -163,14 +159,10 @@ describe("DefaultTableGeneratorService tests", () => {
 
     const result = service.render(table);
     const lines = result.split("\n");
-    const contentLines = lines.filter((l) =>
-      l.startsWith("│") && !l.includes("─")
-    );
+    const contentLines = lines.filter((l) => l.startsWith("│") && !l.includes("─"));
     expect(contentLines.length).toBeGreaterThan(1);
     // Verify all characters are present
-    const allContent = contentLines
-      .map((l) => l.replace(/│/g, "").replace(/ /g, ""))
-      .join("");
+    const allContent = contentLines.map((l) => l.replace(/│/g, "").replace(/ /g, "")).join("");
     expect(allContent).toBe("ABCDEFGHIJKLMNOP");
   });
 
@@ -245,8 +237,7 @@ describe("DefaultTableGeneratorService tests", () => {
 
   test("empty cells render as blank space", () => {
     const service = createService();
-    const table = new Table(1, 2, { maxWidth: 20, padding: 1 })
-      .cell(0, 0, "Hi");
+    const table = new Table(1, 2, { maxWidth: 20, padding: 1 }).cell(0, 0, "Hi");
     // cell(0, 1) not set
 
     const result = service.render(table);
@@ -269,9 +260,7 @@ describe("DefaultTableGeneratorService tests", () => {
     const result = service.render(table);
     const lines = result.split("\n");
     // Filter content lines (between top and bottom borders)
-    const contentLines = lines.filter((l) =>
-      l.startsWith("│") && !l.includes("─")
-    );
+    const contentLines = lines.filter((l) => l.startsWith("│") && !l.includes("─"));
     // Row should have 3 sub-lines due to multi-line content
     expect(contentLines.length).toBe(3);
     expect(contentLines[0]).toContain("line1");
@@ -304,8 +293,7 @@ describe("DefaultTableGeneratorService tests", () => {
 
   test("1x1 table renders correctly", () => {
     const service = createService();
-    const table = new Table(1, 1, { maxWidth: 10, padding: 0 })
-      .cell(0, 0, "Hi");
+    const table = new Table(1, 1, { maxWidth: 10, padding: 0 }).cell(0, 0, "Hi");
 
     const result = service.render(table);
     const lines = result.split("\n");
@@ -319,8 +307,7 @@ describe("DefaultTableGeneratorService tests", () => {
 
   test("padding=0 works", () => {
     const service = createService();
-    const table = new Table(1, 1, { maxWidth: 10, padding: 0 })
-      .cell(0, 0, "AB");
+    const table = new Table(1, 1, { maxWidth: 10, padding: 0 }).cell(0, 0, "AB");
 
     const result = service.render(table);
     const lines = result.split("\n");
@@ -335,22 +322,14 @@ describe("DefaultTableGeneratorService tests", () => {
 
   test("out-of-bounds row index throws", () => {
     const table = new Table(2, 2);
-    expect(() => table.row(5, { align: Align.LEFT })).toThrow(
-      /out of bounds/,
-    );
-    expect(() => table.row(-1, { align: Align.LEFT })).toThrow(
-      /out of bounds/,
-    );
+    expect(() => table.row(5, { align: Align.LEFT })).toThrow(/out of bounds/);
+    expect(() => table.row(-1, { align: Align.LEFT })).toThrow(/out of bounds/);
   });
 
   test("out-of-bounds column index throws", () => {
     const table = new Table(2, 2);
-    expect(() => table.column(5, { flexWeight: 1 })).toThrow(
-      /out of bounds/,
-    );
-    expect(() => table.column(-1, { flexWeight: 1 })).toThrow(
-      /out of bounds/,
-    );
+    expect(() => table.column(5, { flexWeight: 1 })).toThrow(/out of bounds/);
+    expect(() => table.column(-1, { flexWeight: 1 })).toThrow(/out of bounds/);
   });
 
   test("out-of-bounds cell index throws", () => {

package/tests/service/tableGenerator/TableGeneratorServiceProvider.test.ts

@@ -38,8 +38,8 @@ describe("TableGeneratorServiceProvider tests", () => {
     const serviceInfo = await provider.getServiceInfo(cliConfig);
     expect(serviceInfo.commands.length).toEqual(0);
     await provider.initService(context);
-    const service = serviceInfo
-      .service as import("../../../src/service/tableGenerator/DefaultTableGeneratorService.ts").default;
+    const service =
+      serviceInfo.service as import("../../../src/service/tableGenerator/DefaultTableGeneratorService.ts").default;
     expect(service.colorEnabled).toBe(true);
     expect(typeof service.colorFunction).toBe("function");
     expect(typeof service.backgroundColorFunction).toBe("function");

package/tests/service/treePrinter/DefaultTreePrinterService.test.ts

@@ -33,7 +33,9 @@ describe("DefaultTreePrinterService tests", () => {
       label: "Root",
       children: [
         { label: "Child1", children: ["Leaf1", "Leaf2"] },
-        { label: "Child2" },
+        {
+          label: "Child2",
+        },
       ],
     });
 
@@ -51,11 +53,7 @@ describe("DefaultTreePrinterService tests", () => {
 
     const result = service.print({
       label: "Root",
-      children: [
-        "StringChild",
-        { label: "NodeChild", children: ["Nested"] },
-        "Last",
-      ],
+      children: ["StringChild", { label: "NodeChild", children: ["Nested"] }, "Last"],
     });
 
     const lines = result.split("\n");

package/tests/service/treePrinter/TreePrinterServiceProvider.test.ts

@@ -13,9 +13,7 @@ describe("TreePrinterServiceProvider tests", () => {
     const treePrinterServiceProvider = new TreePrinterServiceProvider(100);
     const cliConfig = getCLIConfig();
 
-    const serviceInfo = await treePrinterServiceProvider.getServiceInfo(
-      cliConfig,
-    );
+    const serviceInfo = await treePrinterServiceProvider.getServiceInfo(cliConfig);
     expect(serviceInfo.commands.length).toEqual(0);
     expect(serviceInfo.service).toBeDefined();
   });
@@ -40,15 +38,13 @@ describe("TreePrinterServiceProvider tests", () => {
       ),
     );
 
-    const serviceInfo = await treePrinterServiceProvider.getServiceInfo(
-      cliConfig,
-    );
+    const serviceInfo = await treePrinterServiceProvider.getServiceInfo(cliConfig);
     expect(serviceInfo.commands.length).toEqual(0);
 
     await treePrinterServiceProvider.initService(context);
 
-    const service = serviceInfo
-      .service as import("../../../src/service/treePrinter/DefaultTreePrinterService.ts").default;
+    const service =
+      serviceInfo.service as import("../../../src/service/treePrinter/DefaultTreePrinterService.ts").default;
     expect(service.colorEnabled).toBe(true);
     expect(typeof service.colorFunction).toBe("function");
   });

package/tests/terminal/ImageRenderer.test.ts

@@ -31,11 +31,7 @@ function crc32(data: Uint8Array): number {
   return (crc ^ 0xffffffff) >>> 0;
 }
 
-function buildValidPng(
-  width: number,
-  height: number,
-  colorType: number = 6,
-): Uint8Array {
+function buildValidPng(width: number, height: number, colorType: number = 6): Uint8Array {
   const parts: number[] = [];
 
   // PNG signature
@@ -44,12 +40,7 @@ function buildValidPng(
   function addChunk(type: string, data: Uint8Array) {
     // Length (4 bytes big-endian)
     const len = data.length;
-    parts.push(
-      (len >>> 24) & 0xff,
-      (len >>> 16) & 0xff,
-      (len >>> 8) & 0xff,
-      len & 0xff,
-    );
+    parts.push((len >>> 24) & 0xff, (len >>> 16) & 0xff, (len >>> 8) & 0xff, len & 0xff);
 
     // Type (4 bytes)
     const typeBytes = new TextEncoder().encode(type);

package/tests/terminal/PngDecoder.test.ts

@@ -3,9 +3,7 @@ import { describe, expect, test } from "bun:test";
 import { decodePngToRGBA } from "../../src/terminal/PngDecoder.ts";
 
 // Helper to build a minimal PNG from raw components
-function buildPng(
-  chunks: Array<{ type: string; data: Uint8Array }>,
-): Uint8Array {
+function buildPng(chunks: Array<{ type: string; data: Uint8Array }>): Uint8Array {
   const parts: Uint8Array[] = [];
   // PNG signature
   parts.push(new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]));
@@ -177,9 +175,7 @@ describe("decodePngToRGBA", () => {
       { type: "IHDR", data: makeIHDR(1, 1, 8, 6, 1) },
       { type: "IEND", data: new Uint8Array(0) },
     ]);
-    expect(() => decodePngToRGBA(png)).toThrow(
-      "Interlaced PNGs are not supported",
-    );
+    expect(() => decodePngToRGBA(png)).toThrow("Interlaced PNGs are not supported");
   });
 
   test("throws on unknown filter type", () => {