auq-mcp-server 2.3.0 → 2.5.0

package/dist/src/tui/themes/tokyo-night.js

@@ -91,6 +91,7 @@ export const tokyoNightTheme = {
             successPillBg: "#1a1b26",
             error: "#f7768e",
             info: "#7aa2f7",
+            warning: "#e0af68",
             border: "#24283b",
         },
         markdown: {
@@ -105,6 +106,8 @@ export const tokyoNightTheme = {
             untouched: "#7078A3",
             number: "#c0caf5",
             activeNumber: "#7aa2f7",
+            stale: "#e0af68",
+            abandoned: "#f7768e",
         },
         sessionPicker: {
             border: "#7aa2f7",
@@ -115,6 +118,10 @@ export const tokyoNightTheme = {
             highlightFg: "#9ece6a",
             activeMark: "#7aa2f7",
             progress: "#7dcfff",
+            staleIcon: "#e0af68",
+            staleText: "#e0af68",
+            staleAge: "#e0af68",
+            staleSubtitle: "#7078A3",
         },
     },
 };

package/dist/src/tui/utils/__tests__/staleDetection.test.js

@@ -0,0 +1,118 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { DEFAULT_GRACE_PERIOD, formatStaleToastMessage, isSessionAbandoned, isSessionStale, } from "../staleDetection.js";
+describe("staleDetection", () => {
+    const now = new Date("2026-01-01T12:00:00.000Z");
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(now);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe("isSessionStale", () => {
+        const TWO_HOURS = 7200000; // default staleThreshold from config
+        it("should return true when session is older than threshold", () => {
+            // Session created 3 hours ago, threshold is 2 hours
+            const threeHoursAgo = now.getTime() - 3 * 3600000;
+            expect(isSessionStale(threeHoursAgo, TWO_HOURS)).toBe(true);
+        });
+        it("should return false when session is younger than threshold", () => {
+            // Session created 1 hour ago, threshold is 2 hours
+            const oneHourAgo = now.getTime() - 1 * 3600000;
+            expect(isSessionStale(oneHourAgo, TWO_HOURS)).toBe(false);
+        });
+        it("should return false when session is exactly at threshold", () => {
+            // Edge case: exactly at threshold boundary (not greater than)
+            const exactlyAtThreshold = now.getTime() - TWO_HOURS;
+            expect(isSessionStale(exactlyAtThreshold, TWO_HOURS)).toBe(false);
+        });
+        it("should return false when stale session has recent interaction within grace period", () => {
+            // Session created 3 hours ago (stale), but user interacted 10 minutes ago
+            const threeHoursAgo = now.getTime() - 3 * 3600000;
+            const tenMinutesAgo = now.getTime() - 10 * 60000;
+            expect(isSessionStale(threeHoursAgo, TWO_HOURS, tenMinutesAgo)).toBe(false);
+        });
+        it("should return true when stale session has old interaction outside grace period", () => {
+            // Session created 3 hours ago, last interaction 45 minutes ago (outside 30min grace)
+            const threeHoursAgo = now.getTime() - 3 * 3600000;
+            const fortyFiveMinutesAgo = now.getTime() - 45 * 60000;
+            expect(isSessionStale(threeHoursAgo, TWO_HOURS, fortyFiveMinutesAgo)).toBe(true);
+        });
+        it("should respect custom grace period", () => {
+            // Session created 3 hours ago, last interaction 45 minutes ago
+            // With a 1-hour custom grace period, should NOT be stale
+            const threeHoursAgo = now.getTime() - 3 * 3600000;
+            const fortyFiveMinutesAgo = now.getTime() - 45 * 60000;
+            const oneHourGrace = 3600000;
+            expect(isSessionStale(threeHoursAgo, TWO_HOURS, fortyFiveMinutesAgo, oneHourGrace)).toBe(false);
+        });
+        it("should use DEFAULT_GRACE_PERIOD when no grace period provided", () => {
+            // Interaction 29 minutes ago (within default 30-minute grace)
+            const threeHoursAgo = now.getTime() - 3 * 3600000;
+            const twentyNineMinutesAgo = now.getTime() - 29 * 60000;
+            expect(isSessionStale(threeHoursAgo, TWO_HOURS, twentyNineMinutesAgo)).toBe(false);
+            // Interaction 31 minutes ago (outside default 30-minute grace)
+            const thirtyOneMinutesAgo = now.getTime() - 31 * 60000;
+            expect(isSessionStale(threeHoursAgo, TWO_HOURS, thirtyOneMinutesAgo)).toBe(true);
+        });
+        it("should handle undefined lastInteraction", () => {
+            const threeHoursAgo = now.getTime() - 3 * 3600000;
+            // No interaction => stale if age exceeds threshold
+            expect(isSessionStale(threeHoursAgo, TWO_HOURS, undefined)).toBe(true);
+        });
+        it("should handle zero threshold (always stale if age > 0)", () => {
+            const oneSecondAgo = now.getTime() - 1000;
+            expect(isSessionStale(oneSecondAgo, 0)).toBe(true);
+        });
+    });
+    describe("isSessionAbandoned", () => {
+        it("should return true for 'abandoned' status", () => {
+            expect(isSessionAbandoned("abandoned")).toBe(true);
+        });
+        it("should return false for 'pending' status", () => {
+            expect(isSessionAbandoned("pending")).toBe(false);
+        });
+        it("should return false for 'completed' status", () => {
+            expect(isSessionAbandoned("completed")).toBe(false);
+        });
+        it("should return false for 'in-progress' status", () => {
+            expect(isSessionAbandoned("in-progress")).toBe(false);
+        });
+        it("should return false for 'rejected' status", () => {
+            expect(isSessionAbandoned("rejected")).toBe(false);
+        });
+        it("should return false for 'timed_out' status", () => {
+            expect(isSessionAbandoned("timed_out")).toBe(false);
+        });
+        it("should return false for empty string", () => {
+            expect(isSessionAbandoned("")).toBe(false);
+        });
+    });
+    describe("formatStaleToastMessage", () => {
+        it("should format hours correctly for a 3-hour-old session", () => {
+            const threeHoursAgo = now.getTime() - 3 * 3600000;
+            const message = formatStaleToastMessage("Test Session", threeHoursAgo);
+            expect(message).toBe('Session "Test Session" may be orphaned (created 3h ago)');
+        });
+        it("should show 0h for very recent sessions", () => {
+            const thirtyMinutesAgo = now.getTime() - 30 * 60000;
+            const message = formatStaleToastMessage("New Session", thirtyMinutesAgo);
+            expect(message).toBe('Session "New Session" may be orphaned (created 0h ago)');
+        });
+        it("should show large hour counts for old sessions", () => {
+            const twoDaysAgo = now.getTime() - 48 * 3600000;
+            const message = formatStaleToastMessage("Old Session", twoDaysAgo);
+            expect(message).toBe('Session "Old Session" may be orphaned (created 48h ago)');
+        });
+        it("should handle session title with special characters", () => {
+            const twoHoursAgo = now.getTime() - 2 * 3600000;
+            const message = formatStaleToastMessage("Session \"quoted\"", twoHoursAgo);
+            expect(message).toBe('Session "Session "quoted"" may be orphaned (created 2h ago)');
+        });
+    });
+    describe("DEFAULT_GRACE_PERIOD", () => {
+        it("should be 30 minutes in milliseconds", () => {
+            expect(DEFAULT_GRACE_PERIOD).toBe(1800000);
+        });
+    });
+});

package/dist/src/tui/utils/staleDetection.js

@@ -0,0 +1,51 @@
+/**
+ * Stale Session Detection Utilities
+ *
+ * Pure functions for computing session staleness. No I/O or React dependencies.
+ * Design Decision 4: "Stale is computed flag, not persisted status"
+ * Design Decision 8: "Interaction resets stale check for that session"
+ */
+/**
+ * Default grace period in milliseconds (30 minutes).
+ * If a user interacted with a session within this window, it is not considered stale.
+ */
+export const DEFAULT_GRACE_PERIOD = 1800000; // 30 minutes
+/**
+ * Determine whether a session should be considered stale based on its age,
+ * a configurable threshold, and an optional last-interaction timestamp.
+ *
+ * @param requestTimestamp - When the session was originally created (epoch ms)
+ * @param staleThreshold - Maximum allowed age before a session is stale (ms)
+ * @param lastInteraction - Last time the user interacted with this session (epoch ms)
+ * @param gracePeriod - Time after an interaction during which the session is not stale (ms)
+ * @returns true if the session is stale
+ */
+export function isSessionStale(requestTimestamp, staleThreshold, lastInteraction, gracePeriod = DEFAULT_GRACE_PERIOD) {
+    const now = Date.now();
+    // If the user interacted recently (within grace period), session is not stale
+    if (lastInteraction && now - lastInteraction < gracePeriod) {
+        return false;
+    }
+    return now - requestTimestamp > staleThreshold;
+}
+/**
+ * Check whether a session has been explicitly marked as abandoned
+ * (e.g. AI disconnected).
+ *
+ * @param status - The session's current status string
+ * @returns true if status is "abandoned"
+ */
+export function isSessionAbandoned(status) {
+    return status === "abandoned";
+}
+/**
+ * Build a human-readable toast message for a stale session.
+ *
+ * @param sessionTitle - Display name or ID of the session
+ * @param createdAtMs - Session creation time in epoch milliseconds
+ * @returns Formatted message string
+ */
+export function formatStaleToastMessage(sessionTitle, createdAtMs) {
+    const hoursAgo = Math.floor((Date.now() - createdAtMs) / 3600000);
+    return `Session "${sessionTitle}" may be orphaned (created ${hoursAgo}h ago)`;
+}

package/dist/src/update/__tests__/cache.test.js

@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Mock node:fs/promises and node:os before importing the module under test
+vi.mock("node:fs/promises", () => ({
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+    unlink: vi.fn(),
+}));
+vi.mock("node:os", () => ({
+    homedir: vi.fn(() => "/home/testuser"),
+}));
+import { readFile, writeFile, mkdir, unlink } from "node:fs/promises";
+import { getCachePath, readCache, writeCache, isCacheFresh, shouldSkipVersion, clearUpdateCache, CACHE_TTL, } from "../cache.js";
+describe("cache management", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.env = { ...originalEnv };
+        delete process.env.XDG_CONFIG_HOME;
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        vi.restoreAllMocks();
+    });
+    describe("CACHE_TTL", () => {
+        it("should be 1 hour in milliseconds", () => {
+            expect(CACHE_TTL).toBe(3600000);
+        });
+    });
+    describe("getCachePath", () => {
+        it("should use homedir/.config when XDG_CONFIG_HOME is not set", () => {
+            const path = getCachePath();
+            expect(path).toContain("/home/testuser/.config/auq/update-check.json");
+        });
+        it("should use XDG_CONFIG_HOME when set", () => {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            const path = getCachePath();
+            expect(path).toContain("/custom/config/auq/update-check.json");
+        });
+    });
+    describe("readCache", () => {
+        it("should return parsed cache when file contains valid JSON", async () => {
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+            };
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify(cache));
+            const result = await readCache();
+            expect(result).toEqual(cache);
+        });
+        it("should return null when file is missing", async () => {
+            vi.mocked(readFile).mockRejectedValue(new Error("ENOENT"));
+            const result = await readCache();
+            expect(result).toBeNull();
+        });
+        it("should return null when file contains invalid JSON", async () => {
+            vi.mocked(readFile).mockResolvedValue("not valid json{{{");
+            const result = await readCache();
+            expect(result).toBeNull();
+        });
+    });
+    describe("writeCache", () => {
+        it("should create directory and write JSON", async () => {
+            vi.mocked(mkdir).mockResolvedValue(undefined);
+            vi.mocked(writeFile).mockResolvedValue(undefined);
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+            };
+            await writeCache(cache);
+            expect(mkdir).toHaveBeenCalledWith(expect.stringContaining("auq"), { recursive: true });
+            expect(writeFile).toHaveBeenCalledWith(expect.stringContaining("update-check.json"), JSON.stringify(cache, null, 2), "utf-8");
+        });
+        it("should silently handle write errors", async () => {
+            vi.mocked(mkdir).mockRejectedValue(new Error("EACCES"));
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+            };
+            // Should not throw
+            await expect(writeCache(cache)).resolves.toBeUndefined();
+        });
+    });
+    describe("isCacheFresh", () => {
+        it("should return true for a recent cache (30 min ago)", () => {
+            const cache = {
+                lastCheck: Date.now() - 30 * 60 * 1000, // 30 minutes ago
+                latestVersion: "2.5.0",
+            };
+            expect(isCacheFresh(cache)).toBe(true);
+        });
+        it("should return false for an old cache (2 hours ago)", () => {
+            const cache = {
+                lastCheck: Date.now() - 2 * 60 * 60 * 1000, // 2 hours ago
+                latestVersion: "2.5.0",
+            };
+            expect(isCacheFresh(cache)).toBe(false);
+        });
+    });
+    describe("shouldSkipVersion", () => {
+        it("should return true when skippedVersion matches", () => {
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+                skippedVersion: "2.5.0",
+            };
+            expect(shouldSkipVersion(cache, "2.5.0")).toBe(true);
+        });
+        it("should return false when skippedVersion does not match", () => {
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+                skippedVersion: "2.4.0",
+            };
+            expect(shouldSkipVersion(cache, "2.5.0")).toBe(false);
+        });
+        it("should return false when skippedVersion is undefined", () => {
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+            };
+            expect(shouldSkipVersion(cache, "2.5.0")).toBe(false);
+        });
+    });
+    describe("clearUpdateCache", () => {
+        it("should call unlink on the cache file", async () => {
+            vi.mocked(unlink).mockResolvedValue(undefined);
+            await clearUpdateCache();
+            expect(unlink).toHaveBeenCalledWith(expect.stringContaining("update-check.json"));
+        });
+        it("should silently handle errors when file does not exist", async () => {
+            vi.mocked(unlink).mockRejectedValue(new Error("ENOENT"));
+            await expect(clearUpdateCache()).resolves.toBeUndefined();
+        });
+    });
+});

package/dist/src/update/__tests__/changelog.test.js

@@ -0,0 +1,86 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Mock the cache module before importing changelog
+vi.mock("../cache.js", () => ({
+    readCache: vi.fn(),
+    writeCache: vi.fn(),
+}));
+import { readCache, writeCache } from "../cache.js";
+import { fetchChangelog } from "../changelog.js";
+describe("changelog fetcher", () => {
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Default mock: no cache
+        vi.mocked(readCache).mockResolvedValue(null);
+        vi.mocked(writeCache).mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        vi.restoreAllMocks();
+    });
+    it("should return content and fallbackUrl on successful fetch", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ body: "## Changes\n- Fix bug" }),
+        });
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBe("## Changes\n- Fix bug");
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should return cached changelog without fetching", async () => {
+        vi.mocked(readCache).mockResolvedValue({
+            lastCheck: Date.now(),
+            latestVersion: "2.5.0",
+            changelog: "## Cached changelog",
+            changelogFetchedAt: Date.now(),
+        });
+        globalThis.fetch = vi.fn();
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBe("## Cached changelog");
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+        expect(globalThis.fetch).not.toHaveBeenCalled();
+    });
+    it("should return null content on 403 rate limit", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+        });
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBeNull();
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should return null content on 429 rate limit", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 429,
+        });
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBeNull();
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should return null content on network error", async () => {
+        globalThis.fetch = vi.fn().mockRejectedValue(new Error("network error"));
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBeNull();
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should return null content on non-OK response", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 500,
+        });
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBeNull();
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should always have correct fallbackUrl format", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ body: "content" }),
+        });
+        const result = await fetchChangelog("3.1.0");
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v3.1.0");
+    });
+});

package/dist/src/update/__tests__/checker.test.js

@@ -0,0 +1,148 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Mock dependencies before importing the module under test
+vi.mock("../cache.js", () => ({
+    readCache: vi.fn(),
+    writeCache: vi.fn(),
+    isCacheFresh: vi.fn(),
+    shouldSkipVersion: vi.fn(),
+    clearUpdateCache: vi.fn(),
+}));
+vi.mock("../version.js", () => ({
+    isNewer: vi.fn(),
+    getUpdateType: vi.fn(),
+    getCurrentVersion: vi.fn(() => "1.0.0"),
+}));
+import { readCache, writeCache, isCacheFresh, shouldSkipVersion, clearUpdateCache, } from "../cache.js";
+import { isNewer, getUpdateType, getCurrentVersion } from "../version.js";
+import { UpdateChecker } from "../checker.js";
+describe("UpdateChecker", () => {
+    const originalEnv = { ...process.env };
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Clear env vars that trigger shouldSkipCheck
+        delete process.env.CI;
+        delete process.env.NO_UPDATE_NOTIFIER;
+        delete process.env.NODE_ENV;
+        // Default mocks
+        vi.mocked(readCache).mockResolvedValue(null);
+        vi.mocked(writeCache).mockResolvedValue(undefined);
+        vi.mocked(clearUpdateCache).mockResolvedValue(undefined);
+        vi.mocked(isCacheFresh).mockReturnValue(false);
+        vi.mocked(shouldSkipVersion).mockReturnValue(false);
+        vi.mocked(isNewer).mockReturnValue(false);
+        vi.mocked(getUpdateType).mockReturnValue("patch");
+        vi.mocked(getCurrentVersion).mockReturnValue("1.0.0");
+    });
+    afterEach(() => {
+        process.env = { ...originalEnv };
+        globalThis.fetch = originalFetch;
+        vi.restoreAllMocks();
+    });
+    describe("shouldSkipCheck", () => {
+        it("should return true when CI=true", () => {
+            process.env.CI = "true";
+            const checker = new UpdateChecker("1.0.0");
+            expect(checker.shouldSkipCheck()).toBe(true);
+        });
+        it("should return true when NO_UPDATE_NOTIFIER=1", () => {
+            process.env.NO_UPDATE_NOTIFIER = "1";
+            const checker = new UpdateChecker("1.0.0");
+            expect(checker.shouldSkipCheck()).toBe(true);
+        });
+        it("should return true when NODE_ENV=test", () => {
+            process.env.NODE_ENV = "test";
+            const checker = new UpdateChecker("1.0.0");
+            expect(checker.shouldSkipCheck()).toBe(true);
+        });
+        it("should return false when none of the skip conditions are set", () => {
+            const checker = new UpdateChecker("1.0.0");
+            expect(checker.shouldSkipCheck()).toBe(false);
+        });
+    });
+    describe("check", () => {
+        it("should return null when shouldSkipCheck is true", async () => {
+            process.env.CI = "true";
+            const checker = new UpdateChecker("1.0.0");
+            const result = await checker.check();
+            expect(result).toBeNull();
+        });
+        it("should return UpdateInfo when a newer version is available", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            vi.mocked(isNewer).mockReturnValue(true);
+            vi.mocked(getUpdateType).mockReturnValue("minor");
+            globalThis.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ "dist-tags": { latest: "1.1.0" } }),
+            });
+            const checker = new UpdateChecker("1.0.0");
+            const result = await checker.check();
+            expect(result).not.toBeNull();
+            expect(result?.currentVersion).toBe("1.0.0");
+            expect(result?.latestVersion).toBe("1.1.0");
+            expect(result?.updateType).toBe("minor");
+            expect(result?.changelogUrl).toContain("v1.1.0");
+        });
+        it("should return null when versions are the same", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            vi.mocked(isNewer).mockReturnValue(false);
+            globalThis.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ "dist-tags": { latest: "1.0.0" } }),
+            });
+            const checker = new UpdateChecker("1.0.0");
+            const result = await checker.check();
+            expect(result).toBeNull();
+        });
+        it("should return null on fetch error", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            globalThis.fetch = vi.fn().mockRejectedValue(new Error("network error"));
+            const checker = new UpdateChecker("1.0.0");
+            const result = await checker.check();
+            expect(result).toBeNull();
+        });
+        it("should memoize: two check() calls only fetch once", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            vi.mocked(isNewer).mockReturnValue(true);
+            vi.mocked(getUpdateType).mockReturnValue("patch");
+            globalThis.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ "dist-tags": { latest: "1.0.1" } }),
+            });
+            const checker = new UpdateChecker("1.0.0");
+            const [result1, result2] = await Promise.all([
+                checker.check(),
+                checker.check(),
+            ]);
+            // Both should resolve to the same value
+            expect(result1).toStrictEqual(result2);
+            // Fetch should have been called only once (memoized)
+            expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("clearCache", () => {
+        it("should reset the memoized promise", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            vi.mocked(isNewer).mockReturnValue(true);
+            vi.mocked(getUpdateType).mockReturnValue("patch");
+            globalThis.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ "dist-tags": { latest: "1.0.1" } }),
+            });
+            const checker = new UpdateChecker("1.0.0");
+            // First check
+            const result1 = await checker.check();
+            expect(result1).not.toBeNull();
+            // Clear cache
+            checker.clearCache();
+            // Second check should create a new promise (calls fetch again)
+            const result2 = await checker.check();
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/dist/src/update/__tests__/index.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import * as updateModule from "../index.js";
+describe("update module exports", () => {
+    it("exports UpdateChecker class", () => {
+        expect(typeof updateModule.UpdateChecker).toBe("function");
+    });
+    it("exports fetchChangelog function", () => {
+        expect(typeof updateModule.fetchChangelog).toBe("function");
+    });
+    it("exports cache functions", () => {
+        expect(typeof updateModule.readCache).toBe("function");
+        expect(typeof updateModule.writeCache).toBe("function");
+        expect(typeof updateModule.clearUpdateCache).toBe("function");
+        expect(typeof updateModule.isCacheFresh).toBe("function");
+        expect(typeof updateModule.shouldSkipVersion).toBe("function");
+        expect(typeof updateModule.getCachePath).toBe("function");
+    });
+    it("exports CACHE_TTL as 3600000", () => {
+        expect(updateModule.CACHE_TTL).toBe(3600000);
+    });
+    it("exports installer functions", () => {
+        expect(typeof updateModule.installUpdate).toBe("function");
+        expect(typeof updateModule.getManualCommand).toBe("function");
+    });
+    it("exports package manager functions", () => {
+        expect(typeof updateModule.detectPackageManager).toBe("function");
+    });
+    it("exports PACKAGE_NAME as auq-mcp-server", () => {
+        expect(updateModule.PACKAGE_NAME).toBe("auq-mcp-server");
+    });
+    it("exports version utilities", () => {
+        expect(typeof updateModule.parseVersion).toBe("function");
+        expect(typeof updateModule.isNewer).toBe("function");
+        expect(typeof updateModule.getUpdateType).toBe("function");
+        expect(typeof updateModule.getCurrentVersion).toBe("function");
+    });
+});