Fast version check

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",

src/settings/settings.ts

@@ -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/tools/system/shellStart.test.ts

@@ -23,7 +23,7 @@ describe("shellStartTool", () => {
         description: "Test process",
         timeout: 500, // Generous timeout to ensure sync mode
       },
-      { logger },
+      { logger }
     );
 
     expect(result.mode).toBe("sync");
@@ -41,7 +41,7 @@ describe("shellStartTool", () => {
         description: "Slow command test",
         timeout: 50, // Short timeout to force async mode
       },
-      { logger },
+      { logger }
     );
 
     expect(result.mode).toBe("async");
@@ -57,7 +57,7 @@ describe("shellStartTool", () => {
         command: "nonexistentcommand",
         description: "Invalid command test",
       },
-      { logger },
+      { logger }
     );
 
     expect(result.mode).toBe("sync");
@@ -75,7 +75,7 @@ describe("shellStartTool", () => {
         description: "Sync completion test",
         timeout: 500,
       },
-      { logger },
+      { logger }
     );
 
     // Even sync results should be in processStates
@@ -88,7 +88,7 @@ describe("shellStartTool", () => {
         description: "Async completion test",
         timeout: 50,
       },
-      { logger },
+      { logger }
     );
 
     if (asyncResult.mode === "async") {
@@ -103,7 +103,7 @@ describe("shellStartTool", () => {
         description: "Pipe test",
         timeout: 50, // Force async for interactive command
       },
-      { logger },
+      { logger }
     );
 
     expect(result.mode).toBe("async");
@@ -130,15 +130,15 @@ describe("shellStartTool", () => {
     }
   });
 
-  it("should use default timeout of 100ms", async () => {
+  it("should use default timeout of 10000ms", async () => {
     const result = await shellStartTool.execute(
       {
         command: "sleep 1",
         description: "Default timeout test",
       },
-      { logger },
+      { logger }
     );
 
-    expect(result.mode).toBe("async");
+    expect(result.mode).toBe("sync");
   });
 });

src/tools/system/shellStart.ts

@@ -29,7 +29,9 @@ const parameterSchema = z.object({
   timeout: z
     .number()
     .optional()
-    .describe("Timeout in ms before switching to async mode (default: 100ms)"),
+    .describe(
+      "Timeout in ms before switching to async mode (default: 10s, which usually is sufficient)"
+    ),
 });
 
 const returnSchema = z.union([
@@ -58,7 +60,7 @@ const returnSchema = z.union([
 type Parameters = z.infer<typeof parameterSchema>;
 type ReturnType = z.infer<typeof returnSchema>;
 
-const DEFAULT_TIMEOUT = 100;
+const DEFAULT_TIMEOUT = 1000 * 10;
 
 export const shellStartTool: Tool<Parameters, ReturnType> = {
   name: "shellStart",

src/utils/versionCheck.test.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();
+    });
   });
 });