a very fast and simple version check

Author: bhouston

CHANGELOG.md

@@ -4,6 +4,12 @@
 
 ### Patch Changes
 
+- A very fast and simple background version check
+
+## 0.0.19
+
+### Patch Changes
+
 - ensure the cli works on windows
 
 ## 0.0.18

package.json

@@ -23,6 +23,7 @@
     "build": "tsc --noEmit && tsc",
     "build:ci": "tsc",
     "clean": "rimraf dist",
+    "clean:all": "rimraf dist node_modules",
     "lint": "eslint \"src/**/*.ts\" --fix",
     "format": "prettier --write \"src/**/*.*\"",
     "test": "vitest run",
@@ -51,6 +52,7 @@
     "@anthropic-ai/sdk": "^0.36",
     "chalk": "^5",
     "dotenv": "^16",
+    "semver": "^7.7.1",
     "source-map-support": "^0.5",
     "uuid": "^11",
     "yargs": "^17",

pnpm-lock.yaml

@@ -0,0 +1,12 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+const settingsDir = path.join(os.homedir(), ".mycoder");
+
+export const getSettingsDir = (): string => {
+  if (!fs.existsSync(settingsDir)) {
+    fs.mkdirSync(settingsDir, { recursive: true });
+  }
+  return settingsDir;
+};

src/settings/settings.ts

@@ -1,16 +1,25 @@
+/* eslint-disable max-lines-per-function */
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import {
   generateUpgradeMessage,
   fetchLatestVersion,
   getPackageInfo,
   checkForUpdates,
 } from "./versionCheck.js";
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+import * as path from "path";
+import { getSettingsDir } from "../settings/settings.js";
+
+vi.mock("fs");
+vi.mock("fs/promises");
+vi.mock("../settings/settings.js");
 
 describe("versionCheck", () => {
   describe("generateUpgradeMessage", () => {
     it("returns null when versions are the same", () => {
       expect(generateUpgradeMessage("1.0.0", "1.0.0", "test-package")).toBe(
-        null,
+        null
       );
     });
 
@@ -19,6 +28,12 @@ describe("versionCheck", () => {
       expect(message).toContain("Update available: 1.0.0 → 1.1.0");
       expect(message).toContain("Run 'npm install -g test-package' to update");
     });
+
+    it("returns null when current version is higher", () => {
+      expect(generateUpgradeMessage("2.0.0", "1.0.0", "test-package")).toBe(
+        null
+      );
+    });
   });
 
   describe("fetchLatestVersion", () => {
@@ -43,18 +58,30 @@ describe("versionCheck", () => {
       const version = await fetchLatestVersion("test-package");
       expect(version).toBe("1.1.0");
       expect(mockFetch).toHaveBeenCalledWith(
-        "https://registry.npmjs.org/test-package/latest",
+        "https://registry.npmjs.org/test-package/latest"
       );
     });
 
-    it("returns null when fetch fails", async () => {
+    it("throws error when fetch fails", async () => {
       mockFetch.mockResolvedValueOnce({
         ok: false,
         statusText: "Not Found",
       });
 
-      const version = await fetchLatestVersion("test-package");
-      expect(version).toBe(null);
+      await expect(fetchLatestVersion("test-package")).rejects.toThrow(
+        "Failed to fetch version info: Not Found"
+      );
+    });
+
+    it("throws error when version is missing from response", async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      await expect(fetchLatestVersion("test-package")).rejects.toThrow(
+        "Version info not found in response"
+      );
     });
   });
 
@@ -71,28 +98,69 @@ describe("versionCheck", () => {
   describe("checkForUpdates", () => {
     const mockFetch = vi.fn();
     const originalFetch = global.fetch;
-    const originalEnv = process.env;
+    const mockSettingsDir = "/mock/settings/dir";
+    const versionFilePath = path.join(mockSettingsDir, "lastVersionCheck");
 
     beforeEach(() => {
       global.fetch = mockFetch;
-      process.env = { ...originalEnv };
+      vi.mocked(getSettingsDir).mockReturnValue(mockSettingsDir);
+      vi.mocked(fs.existsSync).mockReturnValue(false);
     });
 
     afterEach(() => {
       global.fetch = originalFetch;
-      process.env = originalEnv;
       vi.clearAllMocks();
     });
 
-    it("returns upgrade message when update available", async () => {
-      process.env.npm_config_global = "true";
+    it("returns null and initiates background check when no cached version", async () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
       mockFetch.mockResolvedValueOnce({
         ok: true,
-        json: () => Promise.resolve({ version: "999.0.0" }), // Much higher version
+        json: () => Promise.resolve({ version: "2.0.0" }),
       });
 
+      const result = await checkForUpdates();
+      expect(result).toBe(null);
+
+      // Wait for setImmediate to complete
+      await new Promise((resolve) => setImmediate(resolve));
+
+      expect(mockFetch).toHaveBeenCalled();
+      expect(fsPromises.writeFile).toHaveBeenCalledWith(
+        versionFilePath,
+        "2.0.0",
+        "utf8"
+      );
+    });
+
+    it("returns upgrade message when cached version is newer", async () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fsPromises.readFile).mockResolvedValue("2.0.0");
+
       const result = await checkForUpdates();
       expect(result).toContain("Update available");
     });
+
+    it("handles errors gracefully during version check", async () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fsPromises.readFile).mockRejectedValue(new Error("Test error"));
+
+      const result = await checkForUpdates();
+      expect(result).toBe(null);
+    });
+
+    it("handles errors gracefully during background update", async () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      mockFetch.mockRejectedValue(new Error("Network error"));
+
+      const result = await checkForUpdates();
+      expect(result).toBe(null);
+
+      // Wait for setImmediate to complete
+      await new Promise((resolve) => setImmediate(resolve));
+
+      // Verify the error was handled
+      expect(fsPromises.writeFile).not.toHaveBeenCalled();
+    });
   });
 });

src/utils/versionCheck.test.ts

@@ -1,100 +1,93 @@
 import { Logger } from "./logger.js";
 import chalk from "chalk";
 import { createRequire } from "module";
+import * as path from "path";
 import type { PackageJson } from "type-fest";
+import { getSettingsDir } from "../settings/settings.js";
+import * as fsPromises from "fs/promises";
+import * as fs from "fs";
+import semver from "semver";
 
 const require = createRequire(import.meta.url);
 const logger = new Logger({ name: "version-check" });
 
-/**
- * Gets the current package info from package.json
- */
 export function getPackageInfo(): {
-  name: string | undefined;
-  version: string | undefined;
+  name: string;
+  version: string;
 } {
   const packageInfo = require("../../package.json") as PackageJson;
+  if (!packageInfo.name || !packageInfo.version) {
+    throw new Error("Unable to determine package info");
+  }
+
   return {
     name: packageInfo.name,
     version: packageInfo.version,
   };
 }
 
-/**
- * Checks if the package is running as a global npm package
- */
-export function isGlobalPackage(): boolean {
-  return !!process.env.npm_config_global;
-}
+export async function fetchLatestVersion(packageName: string): Promise<string> {
+  const registryUrl = `https://registry.npmjs.org/${packageName}/latest`;
+  const response = await fetch(registryUrl);
 
-/**
- * Fetches the latest version of a package from npm registry
- */
-export async function fetchLatestVersion(
-  packageName: string,
-): Promise<string | null> {
-  try {
-    const registryUrl = `https://registry.npmjs.org/${packageName}/latest`;
-    const response = await fetch(registryUrl);
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch version info: ${response.statusText}`);
-    }
+  if (!response.ok) {
+    throw new Error(`Failed to fetch version info: ${response.statusText}`);
+  }
 
-    const data = (await response.json()) as { version: string | undefined };
-    return data.version ?? null;
-  } catch (error) {
-    logger.warn(
-      "Error fetching latest version:",
-      error instanceof Error ? error.message : String(error),
-    );
-    return null;
+  const data = (await response.json()) as { version: string | undefined };
+  if (!data.version) {
+    throw new Error("Version info not found in response");
   }
+  return data.version;
 }
 
-/**
- * Generates an upgrade message if versions differ
- */
 export function generateUpgradeMessage(
   currentVersion: string,
   latestVersion: string,
-  packageName: string,
+  packageName: string
 ): string | null {
-  return currentVersion !== latestVersion
+  return semver.gt(latestVersion, currentVersion)
     ? chalk.green(
-        `  Update available: ${currentVersion} → ${latestVersion}\n  Run 'npm install -g ${packageName}' to update`,
+        `  Update available: ${currentVersion} → ${latestVersion}\n  Run 'npm install -g ${packageName}' to update`
       )
     : null;
 }
 
-/**
- * Checks if a newer version of the package is available on npm.
- * Only runs check when package is installed globally.
- *
- * @returns Upgrade message string if update available, null otherwise
- */
 export async function checkForUpdates(): Promise<string | null> {
   try {
     const { name: packageName, version: currentVersion } = getPackageInfo();
 
-    if (!packageName || !currentVersion) {
-      logger.warn("Unable to determine current package name or version");
-      return null;
+    const settingDir = getSettingsDir();
+    const versionFilePath = path.join(settingDir, "lastVersionCheck");
+    if (fs.existsSync(versionFilePath)) {
+      const lastVersionCheck = await fsPromises.readFile(
+        versionFilePath,
+        "utf8"
+      );
+      return generateUpgradeMessage(
+        currentVersion,
+        lastVersionCheck,
+        packageName
+      );
     }
 
-    const latestVersion = await fetchLatestVersion(packageName);
+    fetchLatestVersion(packageName)
+      .then(async (latestVersion) => {
+        return fsPromises.writeFile(versionFilePath, latestVersion, "utf8");
+      })
+      .catch((error) => {
+        logger.warn(
+          "Error fetching latest version:",
+          error instanceof Error ? error.message : String(error)
+        );
+      });
 
-    if (!latestVersion) {
-      logger.warn("Unable to determine latest published version");
-      return null;
-    }
-
-    return generateUpgradeMessage(currentVersion, latestVersion, packageName);
+    return null;
   } catch (error) {
     // Log error but don't throw to handle gracefully
     logger.warn(
       "Error checking for updates:",
-      error instanceof Error ? error.message : String(error),
+      error instanceof Error ? error.message : String(error)
     );
     return null;
   }