fix(cli): exit gracefully (#1144)

Author: mathio

.changeset/sour-lemons-cry.md

@@ -0,0 +1,5 @@
+---
+"lingo.dev": patch
+---
+
+exit cli gracefully

packages/cli/src/cli/cmd/i18n.ts

@@ -24,8 +24,7 @@ import createProcessor from "../processor";
 import { withExponentialBackoff } from "../utils/exp-backoff";
 import trackEvent from "../utils/observability";
 import { createDeltaProcessor } from "../utils/delta";
-import { tryReadFile, writeFile } from "../utils/fs";
-import { flatten, unflatten } from "flat";
+import { exitGracefully } from "../utils/exit-gracefully";
 
 export default new Command()
   .command("i18n")
@@ -510,6 +509,7 @@ export default new Command()
           flags,
         });
       }
+      exitGracefully();
     } catch (error: any) {
       ora.fail(error.message);
 

packages/cli/src/cli/cmd/run/index.ts

@@ -12,9 +12,9 @@ import {
   pauseIfDebug,
   renderSummary,
 } from "../../utils/ui";
-import chalk from "chalk";
 import trackEvent from "../../utils/observability";
 import { determineAuthId } from "./_utils";
+import { exitGracefully } from "../../utils/exit-gracefully";
 
 export default new Command()
   .command("run")
@@ -117,6 +117,7 @@ export default new Command()
         config: ctx.config,
         flags: ctx.flags,
       });
+      exitGracefully();
     } catch (error: any) {
       trackEvent(authId || "unknown", "cmd.run.error", {});
       process.exit(1);

packages/cli/src/cli/cmd/status.ts

@@ -20,6 +20,7 @@ import Table from "cli-table3";
 import { createDeltaProcessor } from "../utils/delta";
 import trackEvent from "../utils/observability";
 import { minimatch } from "minimatch";
+import { exitGracefully } from "../utils/exit-gracefully";
 
 // Define types for our language stats
 interface LanguageStats {
@@ -626,6 +627,7 @@ export default new Command()
         totalWordsToTranslate,
         authenticated: !!authId,
       });
+      exitGracefully();
     } catch (error: any) {
       ora.fail(error.message);
       trackEvent(authId || "status", "cmd.status.error", {

packages/cli/src/cli/utils/exit-gracefully.spec.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { exitGracefully } from "./exit-gracefully";
+
+// Mock process.exit
+const mockExit: any = vi.fn();
+const originalProcess = global.process;
+
+describe("exitGracefully", () => {
+  beforeEach(() => {
+    // Mock process.exit
+    vi.spyOn(process, "exit").mockImplementation(mockExit);
+
+    // Mock process._getActiveHandles and _getActiveRequests
+    Object.defineProperty(process, "_getActiveHandles", {
+      value: vi.fn(),
+      writable: true,
+    });
+    Object.defineProperty(process, "_getActiveRequests", {
+      value: vi.fn(),
+      writable: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.clearAllTimers();
+    mockExit.mockClear();
+  });
+
+  it("should exit immediately when no pending operations", () => {
+    // Mock no pending operations
+    (process as any)._getActiveHandles.mockReturnValue([]);
+    (process as any)._getActiveRequests.mockReturnValue([]);
+
+    exitGracefully();
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  it("should wait and retry when there are pending operations", () => {
+    vi.useFakeTimers();
+
+    // Mock pending operations
+    (process as any)._getActiveHandles.mockReturnValue([
+      { hasRef: () => true, close: () => {} },
+    ]);
+    (process as any)._getActiveRequests.mockReturnValue([]);
+
+    exitGracefully();
+
+    // Should not exit immediately
+    expect(mockExit).not.toHaveBeenCalled();
+
+    // Fast-forward time to trigger retry
+    vi.advanceTimersByTime(250);
+
+    // Should still not exit if operations are pending
+    expect(mockExit).not.toHaveBeenCalled();
+
+    // Fast-forward to max wait time
+    vi.advanceTimersByTime(1750);
+
+    // Should exit after max wait time
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  it("should exit after max wait interval even with pending operations", () => {
+    vi.useFakeTimers();
+
+    // Mock persistent pending operations
+    (process as any)._getActiveHandles.mockReturnValue([
+      { hasRef: () => true, close: () => {} },
+    ]);
+    (process as any)._getActiveRequests.mockReturnValue([]);
+
+    exitGracefully();
+
+    // Fast-forward to max wait time (2000ms)
+    vi.advanceTimersByTime(2000);
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  it("should handle standard process handles correctly", () => {
+    // Mock only standard handles
+    (process as any)._getActiveHandles.mockReturnValue([
+      process.stdin,
+      process.stdout,
+      process.stderr,
+    ]);
+    (process as any)._getActiveRequests.mockReturnValue([]);
+
+    exitGracefully();
+
+    // Should exit immediately as standard handles are filtered out
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  it("should handle timers without ref correctly", () => {
+    // Mock timers without ref
+    (process as any)._getActiveHandles.mockReturnValue([
+      { hasRef: () => false },
+    ]);
+    (process as any)._getActiveRequests.mockReturnValue([]);
+
+    exitGracefully();
+
+    // Should exit immediately as timers without ref are filtered out
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  it("should detect file watchers correctly", () => {
+    // Mock file watcher handles
+    (process as any)._getActiveHandles.mockReturnValue([{ close: () => {} }]);
+    (process as any)._getActiveRequests.mockReturnValue([]);
+
+    exitGracefully();
+
+    // Should not exit immediately due to file watcher
+    expect(mockExit).not.toHaveBeenCalled();
+  });
+
+  it("should detect pending requests correctly", () => {
+    // Mock pending requests
+    (process as any)._getActiveHandles.mockReturnValue([]);
+    (process as any)._getActiveRequests.mockReturnValue([
+      { someRequest: true },
+    ]);
+
+    exitGracefully();
+
+    // Should not exit immediately due to pending requests
+    expect(mockExit).not.toHaveBeenCalled();
+  });
+
+  it("should handle elapsed time parameter correctly", () => {
+    vi.useFakeTimers();
+
+    // Mock pending operations
+    (process as any)._getActiveHandles.mockReturnValue([
+      { hasRef: () => true, close: () => {} },
+    ]);
+    (process as any)._getActiveRequests.mockReturnValue([]);
+
+    // Start with 1500ms already elapsed
+    exitGracefully(1500);
+
+    // Should exit after 500ms more (reaching 2000ms max)
+    vi.advanceTimersByTime(500);
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  it("should exit immediately when elapsed time exceeds max wait interval", () => {
+    // Mock pending operations but start with elapsed time > 2000ms
+    (process as any)._getActiveHandles.mockReturnValue([
+      { hasRef: () => true, close: () => {} },
+    ]);
+    (process as any)._getActiveRequests.mockReturnValue([]);
+
+    exitGracefully(2500);
+
+    // Should exit immediately as elapsed time exceeds max wait interval
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  it("should handle mixed types of pending operations", () => {
+    vi.useFakeTimers();
+
+    // Mock mixed pending operations
+    (process as any)._getActiveHandles.mockReturnValue([
+      { hasRef: () => true, close: () => {} },
+      { hasRef: () => false }, // Timer without ref
+      process.stdin, // Standard handle
+    ]);
+    (process as any)._getActiveRequests.mockReturnValue([
+      { someRequest: true },
+    ]);
+
+    exitGracefully();
+
+    // Should not exit immediately due to mixed pending operations
+    expect(mockExit).not.toHaveBeenCalled();
+
+    // Fast-forward to max wait time
+    vi.advanceTimersByTime(2000);
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+});

packages/cli/src/cli/utils/exit-gracefully.ts

@@ -0,0 +1,56 @@
+const STEP_WAIT_INTERVAL = 250;
+const MAX_WAIT_INTERVAL = 2000;
+
+export function exitGracefully(elapsedMs = 0) {
+  // Check if there are any pending operations
+  const hasPendingOperations = checkForPendingOperations();
+
+  if (hasPendingOperations && elapsedMs < MAX_WAIT_INTERVAL) {
+    // Wait a bit longer if there are pending operations
+    setTimeout(
+      () => exitGracefully(elapsedMs + STEP_WAIT_INTERVAL),
+      STEP_WAIT_INTERVAL,
+    );
+  } else {
+    // Exit immediately if no pending operations
+    process.exit(0);
+  }
+}
+
+function checkForPendingOperations(): boolean {
+  // Check for active handles and requests using internal Node.js methods
+  const activeHandles = (process as any)._getActiveHandles?.() || [];
+  const activeRequests = (process as any)._getActiveRequests?.() || [];
+
+  // Filter out standard handles that are always present
+  const nonStandardHandles = activeHandles.filter((handle: any) => {
+    // Skip standard handles like process.stdin, process.stdout, etc.
+    if (
+      handle === process.stdin ||
+      handle === process.stdout ||
+      handle === process.stderr
+    ) {
+      return false;
+    }
+    // Skip timers that are part of the normal process
+    if (
+      handle &&
+      typeof handle === "object" &&
+      "hasRef" in handle &&
+      !handle.hasRef()
+    ) {
+      return false;
+    }
+    return true;
+  });
+
+  // Check if there are any file watchers or other async operations
+  const hasFileWatchers = nonStandardHandles.some(
+    (handle: any) => handle && typeof handle === "object" && "close" in handle,
+  );
+
+  // Check for pending promises or async operations
+  const hasPendingPromises = activeRequests.length > 0;
+
+  return nonStandardHandles.length > 0 || hasFileWatchers || hasPendingPromises;
+}