From 44b3808f10f8e0b8cb802c1a79705fcae9f3927d Mon Sep 17 00:00:00 2001
From: luch91 <luchijudith@gmail.com>
Date: Thu, 28 May 2026 22:30:36 +0100
Subject: [PATCH] fix(system): handle ENOENT in checkCommand and throw on
 unmatched version in getVersion

---
 src/lib/clients/system.ts | 34 +++++++++++++++++++---------------
 tests/libs/system.test.ts | 29 ++++++++++++++++++++++++++---
 2 files changed, 45 insertions(+), 18 deletions(-)

diff --git a/src/lib/clients/system.ts b/src/lib/clients/system.ts
index 30cb4eb4..8ba5536e 100644
--- a/src/lib/clients/system.ts
+++ b/src/lib/clients/system.ts
@@ -9,7 +9,7 @@ export async function checkCommand(command: string, toolName: string): Promise<v
   try {
     await util.promisify(exec)(command);
   }catch (error:any) {
-    if (error.stderr) {
+    if (error.code === 'ENOENT' || error.stderr) {
       throw new MissingRequirementError(toolName);
     }
   }
@@ -50,24 +50,28 @@ export function openUrl(url: string): Promise<ChildProcess> {
 }
 
 export async function getVersion(toolName: string): Promise<string> {
+  let toolResponse: {stdout?: string; stderr?: string};
+
   try {
-    const toolResponse = await util.promisify(exec)(`${toolName} --version`);
+    toolResponse = await util.promisify(exec)(`${toolName} --version`);
+  } catch (error) {
+    throw new Error(`Error getting ${toolName} version.`);
+  }
 
-    if (toolResponse.stderr) {
-      throw new Error(toolResponse.stderr);
-    }
+  if (toolResponse.stderr) {
+    throw new Error(`Error getting ${toolName} version.`);
+  }
 
-    try {
-      const versionMatch = toolResponse.stdout.match(/(\d+\.\d+\.\d+)/);
-      if (versionMatch) {
-        return versionMatch[1];
-      }
-    } catch (err) {
-      throw new Error(`Could not parse ${toolName} version.`);
-    }
-  } catch (error) {
+  if (toolResponse.stdout == null) {
     throw new Error(`Error getting ${toolName} version.`);
   }
 
-  return "";
+  const versionMatch = toolResponse.stdout.match(/(\d+\.\d+\.\d+)/);
+  if (versionMatch) {
+    return versionMatch[1];
+  }
+
+  throw new Error(
+    `Could not parse ${toolName} version from output: "${toolResponse.stdout}". Expected format: X.Y.Z`
+  );
 }
diff --git a/tests/libs/system.test.ts b/tests/libs/system.test.ts
index 5bcd80a4..749a6f60 100644
--- a/tests/libs/system.test.ts
+++ b/tests/libs/system.test.ts
@@ -70,13 +70,15 @@ describe("System Functions - Error Paths", () => {
     await expect(getVersion(toolName)).rejects.toThrow(`Error getting ${toolName} version.`);
   });
 
-  test("getVersion returns '' if stdout is empty", async () => {
+  test("getVersion throws when stdout does not match version pattern", async () => {
     vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
       stdout: "",
       stderr: ""
     }));
-    const result = await getVersion('git');
-    expect(result).toBe("");
+    const toolName = "git";
+    await expect(getVersion(toolName)).rejects.toThrow(
+      `Could not parse ${toolName} version from output`
+    );
   });
 
   test("getVersion throw error if stdout undefined", async () => {
@@ -87,6 +89,17 @@ describe("System Functions - Error Paths", () => {
     await expect(getVersion(toolName)).rejects.toThrow(`Error getting ${toolName} version.`);
   });
 
+  test("getVersion throws when stdout has non-matching version format (e.g. major-only)", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "Docker version 25",
+      stderr: ""
+    }));
+    const toolName = "docker";
+    await expect(getVersion(toolName)).rejects.toThrow(
+      `Could not parse ${toolName} version from output`
+    );
+  });
+
   test("checkCommand returns false if the command does not exist", async () => {
     vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject({
       stdout: "",
@@ -96,6 +109,16 @@ describe("System Functions - Error Paths", () => {
     await expect(checkCommand(`${toolName} --version`, toolName)).rejects.toThrow(new MissingRequirementError(toolName));
   });
 
+  test("checkCommand throws MissingRequirementError when binary is not installed (ENOENT)", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject({
+      code: 'ENOENT',
+      stderr: '',
+      message: 'spawn ENOENT'
+    }));
+    const toolName = 'docker';
+    await expect(checkCommand(`${toolName} --version`, toolName)).rejects.toThrow(new MissingRequirementError(toolName));
+  });
+
   test("executeCommand throws an error if the command fails", async () => {
     vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution failed")));
     await expect(executeCommand({