fix: infinite loops, resource leaks, and memory management issues

bunfig.toml

@@ -1,3 +1,13 @@
 [install]
 exact = true
-saveTextLockfile = true
+saveTextLockfile = true
+
+[test]
+coverage.exclude = [
+  "**/dist/**",
+  "**/node_modules/**",
+  "**/*.d.ts",
+  "**/test/**",
+  "**/*.test.ts",
+  "**/*.test.js"
+]

package.json

@@ -33,7 +33,7 @@
     "deploy": "turbo deploy",
     "translate": "turbo translate",
     "typecheck": "turbo typecheck",
-    "ci:local": "bunx turbo format lint build attw publint test:coverage --concurrency=14 --summarize",
+    "ci:local": "bunx turbo format:biome lint build attw publint test:coverage --concurrency=14 --summarize",
     "postinstall": "lefthook install",
     "test:typecheck": "cd test && bunx tsc",
     "test:e2e": "bun test test/*.ts --coverage --preload ./test/scripts/setup-platform-resources.ts",

sdk/cli/src/commands/login.test.ts

@@ -0,0 +1,154 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, expect, mock, test } from "bun:test";
+import { Readable } from "node:stream";
+
+// Since the login command is complex with dependencies, we'll test the STDIN reading logic separately
+// by extracting it into a testable function
+describe("login STDIN reading", () => {
+  test("reads token from STDIN properly", async () => {
+    const testToken = "test-token-123";
+
+    // Create a mock stdin stream
+    const mockStdin = new Readable({
+      read() {
+        this.push(testToken);
+        this.push(null); // End the stream
+      },
+    });
+
+    // Mock the STDIN reading logic
+    const readStdinToken = async (): Promise<string> => {
+      const chunks: Buffer[] = [];
+      let timeout: NodeJS.Timeout | undefined;
+
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          reject(new Error("Timeout reading from STDIN after 30 seconds"));
+        }, 30_000);
+      });
+
+      try {
+        const readPromise = (async () => {
+          for await (const chunk of mockStdin) {
+            chunks.push(Buffer.from(chunk));
+          }
+          return Buffer.concat(chunks).toString().trim();
+        })();
+
+        const result = await Promise.race([readPromise, timeoutPromise]);
+        return result;
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+    };
+
+    const result = await readStdinToken();
+    expect(result).toBe(testToken);
+  });
+
+  test("handles timeout correctly", async () => {
+    // Create a mock stdin that never ends
+    const mockStdin = new Readable({
+      read() {
+        // Don't push null, keep stream open
+      },
+    });
+
+    const readStdinTokenWithShortTimeout = async (): Promise<string> => {
+      const chunks: Buffer[] = [];
+      let timeout: NodeJS.Timeout | undefined;
+
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          reject(new Error("Timeout reading from STDIN after 30 seconds"));
+        }, 10); // Very short timeout for test
+      });
+
+      try {
+        const readPromise = (async () => {
+          for await (const chunk of mockStdin) {
+            chunks.push(Buffer.from(chunk));
+          }
+          return Buffer.concat(chunks).toString().trim();
+        })();
+
+        const result = await Promise.race([readPromise, timeoutPromise]);
+        return result;
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+    };
+
+    await expect(readStdinTokenWithShortTimeout()).rejects.toThrow("Timeout reading from STDIN after 30 seconds");
+  });
+
+  test("properly cleans up timeout on success", async () => {
+    const testToken = "cleanup-test-token";
+    let timeoutCleared = false;
+
+    // Mock setTimeout and clearTimeout to verify cleanup
+    const originalSetTimeout = global.setTimeout;
+    const originalClearTimeout = global.clearTimeout;
+
+    // biome-ignore lint/suspicious/noExplicitAny: Test mocking requires any
+    global.setTimeout = mock((fn: any, delay: number) => {
+      return originalSetTimeout(fn, delay);
+      // biome-ignore lint/suspicious/noExplicitAny: Test mocking requires any
+    }) as any;
+
+    // biome-ignore lint/suspicious/noExplicitAny: Test mocking requires any
+    global.clearTimeout = mock((id: any) => {
+      timeoutCleared = true;
+      return originalClearTimeout(id);
+      // biome-ignore lint/suspicious/noExplicitAny: Test mocking requires any
+    }) as any;
+
+    const mockStdin = new Readable({
+      read() {
+        this.push(testToken);
+        this.push(null);
+      },
+    });
+
+    const readStdinTokenWithCleanup = async (): Promise<string> => {
+      const chunks: Buffer[] = [];
+      let timeout: NodeJS.Timeout | undefined;
+
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          reject(new Error("Timeout reading from STDIN after 30 seconds"));
+        }, 30_000);
+      });
+
+      try {
+        const readPromise = (async () => {
+          for await (const chunk of mockStdin) {
+            chunks.push(Buffer.from(chunk));
+          }
+          return Buffer.concat(chunks).toString().trim();
+        })();
+
+        const result = await Promise.race([readPromise, timeoutPromise]);
+        return result;
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+    };
+
+    const result = await readStdinTokenWithCleanup();
+
+    expect(result).toBe(testToken);
+    expect(timeoutCleared).toBe(true);
+    expect(global.clearTimeout).toHaveBeenCalled();
+
+    // Restore original functions
+    global.setTimeout = originalSetTimeout;
+    global.clearTimeout = originalClearTimeout;
+  });
+});

sdk/cli/src/commands/login.ts

@@ -53,16 +53,33 @@ export function loginCommand(): Command {
         if (cmd.args.length > 0) {
           cancel("A token should be provided using STDIN, not as an argument");
         }
-        personalAccessToken = await Promise.race([
-          (async () => {
-            const chunks: Buffer[] = [];
-            for await (const chunk of process.stdin) {
-              chunks.push(Buffer.from(chunk));
+        personalAccessToken = await (async () => {
+          const chunks: Buffer[] = [];
+          let timeout: NodeJS.Timeout | undefined;
+
+          // Set up a timeout to prevent hanging if STDIN never closes
+          const timeoutPromise = new Promise<never>((_, reject) => {
+            timeout = setTimeout(() => {
+              reject(new Error("Timeout reading from STDIN after 30 seconds"));
+            }, 30_000);
+          });
+
+          try {
+            const readPromise = (async () => {
+              for await (const chunk of process.stdin) {
+                chunks.push(Buffer.from(chunk));
+              }
+              return Buffer.concat(chunks).toString().trim();
+            })();
+
+            const result = await Promise.race([readPromise, timeoutPromise]);
+            return result;
+          } finally {
+            if (timeout) {
+              clearTimeout(timeout);
             }
-            return Buffer.concat(chunks).toString().trim();
-          })(),
-          new Promise<string>((resolve) => setTimeout(() => resolve(""), 1_000)),
-        ]);
+          }
+        })();
         try {
           validate(PersonalAccessTokenSchema, personalAccessToken);
         } catch {

sdk/cli/src/commands/platform/utils/wait-for-completion.test.ts

@@ -0,0 +1,97 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, expect, mock, test } from "bun:test";
+import { waitForCompletion } from "./wait-for-completion.js";
+
+// Mock the settlemint client and services
+const mockRead = mock(() => Promise.resolve({ status: "COMPLETED" }));
+const mockRestart = mock(() => Promise.resolve());
+
+const mockService = {
+  read: mockRead,
+  restart: mockRestart,
+};
+
+const mockSettlemintClient = {
+  blockchainNetwork: mockService,
+  blockchainNode: mockService,
+  customDeployment: mockService,
+  insights: mockService,
+  integrationTool: mockService,
+  loadBalancer: mockService,
+  middleware: mockService,
+  privateKey: mockService,
+  storage: mockService,
+  // biome-ignore lint/suspicious/noExplicitAny: Test mocking requires any
+} as any;
+
+describe("waitForCompletion", () => {
+  test("resolves immediately for workspace resource type", async () => {
+    const result = await waitForCompletion({
+      settlemint: mockSettlemintClient,
+      type: "workspace",
+      uniqueName: "test-workspace",
+      action: "deploy",
+    });
+
+    expect(result).toBe(true);
+  });
+
+  test("resolves immediately for application resource type", async () => {
+    const result = await waitForCompletion({
+      settlemint: mockSettlemintClient,
+      type: "application",
+      uniqueName: "test-app",
+      action: "deploy",
+    });
+
+    expect(result).toBe(true);
+  });
+
+  test("calls service read method", async () => {
+    // Mock service that completes immediately
+    const mockCompleteRead = mock(() => Promise.resolve({ status: "COMPLETED" }));
+    const completeMockService = { read: mockCompleteRead, restart: mockRestart };
+    // biome-ignore lint/suspicious/noExplicitAny: Test mocking requires any
+    const completeMockClient = { blockchainNetwork: completeMockService } as any;
+
+    const result = await waitForCompletion({
+      settlemint: completeMockClient,
+      type: "blockchain network",
+      uniqueName: "test-network",
+      action: "deploy",
+    });
+
+    expect(result).toBe(true);
+    expect(mockCompleteRead).toHaveBeenCalledWith("test-network");
+  });
+
+  test("handles failed status correctly", async () => {
+    const mockFailedRead = mock(() => Promise.resolve({ status: "FAILED" }));
+    const failedMockService = { read: mockFailedRead, restart: mockRestart };
+    // biome-ignore lint/suspicious/noExplicitAny: Test mocking requires any
+    const failedMockClient = { blockchainNetwork: failedMockService } as any;
+
+    const result = await waitForCompletion({
+      settlemint: failedMockClient,
+      type: "blockchain network",
+      uniqueName: "test-network",
+      action: "deploy",
+    });
+
+    expect(result).toBe(false);
+  });
+
+  test("throws error for unsupported service type", async () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Test mocking requires any
+    const mockClientWithoutService = {} as any;
+
+    await expect(() =>
+      waitForCompletion({
+        settlemint: mockClientWithoutService,
+        type: "blockchain network" as const,
+        uniqueName: "test-network",
+        action: "deploy",
+      }),
+    ).toThrow("Service blockchainNetwork does not support status checking");
+  });
+});

sdk/cli/src/utils/parse-number.test.ts

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, expect, test } from "bun:test";
+import { parseNumber } from "./parse-number.js";
+
+describe("parseNumber", () => {
+  test("parses valid integer strings", () => {
+    expect(parseNumber("123")).toBe(123);
+    expect(parseNumber("0")).toBe(0);
+    expect(parseNumber("-42")).toBe(-42);
+  });
+
+  test("parses valid decimal strings", () => {
+    expect(parseNumber("3.14")).toBe(3.14);
+    expect(parseNumber("-2.5")).toBe(-2.5);
+    expect(parseNumber("0.0")).toBe(0);
+  });
+
+  test("handles whitespace trimming", () => {
+    expect(parseNumber("  123  ")).toBe(123);
+    expect(parseNumber("\t42\n")).toBe(42);
+    expect(parseNumber(" -3.14 ")).toBe(-3.14);
+  });
+
+  test("throws error for non-string input", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Testing type validation
+    expect(() => parseNumber(123 as any)).toThrow("Value must be a string");
+    // biome-ignore lint/suspicious/noExplicitAny: Testing type validation
+    expect(() => parseNumber(null as any)).toThrow("Value must be a string");
+    // biome-ignore lint/suspicious/noExplicitAny: Testing type validation
+    expect(() => parseNumber(undefined as any)).toThrow("Value must be a string");
+  });
+
+  test("throws error for empty strings", () => {
+    expect(() => parseNumber("")).toThrow("Value cannot be empty");
+    expect(() => parseNumber("   ")).toThrow("Value cannot be empty");
+    expect(() => parseNumber("\t\n")).toThrow("Value cannot be empty");
+  });
+
+  test("throws error for invalid number strings", () => {
+    expect(() => parseNumber("abc")).toThrow('"abc" is not a valid number');
+    expect(() => parseNumber("12.34.56")).toThrow('"12.34.56" is not a valid number');
+    expect(() => parseNumber("not-a-number")).toThrow('"not-a-number" is not a valid number');
+  });
+
+  test("throws error for infinity values", () => {
+    expect(() => parseNumber("Infinity")).toThrow('"Infinity" is not a finite number');
+    expect(() => parseNumber("-Infinity")).toThrow('"-Infinity" is not a finite number');
+  });
+
+  test("handles scientific notation", () => {
+    expect(parseNumber("1e5")).toBe(100000);
+    expect(parseNumber("2.5e-2")).toBe(0.025);
+    expect(parseNumber("-3e4")).toBe(-30000);
+  });
+
+  test("handles edge cases", () => {
+    expect(parseNumber("0")).toBe(0);
+    expect(parseNumber("-0")).toBe(-0);
+    expect(parseNumber("0.000001")).toBe(0.000001);
+  });
+});