about-system 0.10.8 → 0.10.10

package/src/cache/cache-config.ts

@@ -17,7 +17,7 @@ export const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");
  * Values are in milliseconds
  *
  * @constant
- * @property {number} ip - IP information cache (5 minutes)
+ * @property {number} ip - IP information cache (10 minutes)
  * @property {number} cpu - CPU information cache (24 hours)
  * @property {number} gpu - GPU information cache (24 hours)
  * @property {number} os - OS information cache (24 hours)
@@ -36,7 +36,7 @@ export const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");
  * @property {number} mount_points - Mount points cache (10 minutes)
  */
 export const CACHE_DURATION = {
-  ip: 5 * 60 * 1000,
+  ip: 10 * 60 * 1000,
   cpu: 24 * 60 * 60 * 1000,
   gpu: 24 * 60 * 60 * 1000,
   os: 24 * 60 * 60 * 1000,

package/src/system-info-api.ts

@@ -11,7 +11,7 @@
 
 import os from "os";
 import fs from "fs";
-import https from "https";
+import { fetchIPInfo } from "./utils/network";
 import path from "path";
 import type { SystemInfo, SystemInfoOptions } from "./systeminfo-types";
 import { CACHE_FILE } from "./info/settings"; // Using CACHE_FILE from settings to ensure consistency
@@ -50,7 +50,7 @@ import { shell, packages, containers } from "./info/software";
  * Values are in milliseconds
  */
 const CACHE_DURATION = {
-  ip: 5 * 60 * 1000,
+  ip: 10 * 60 * 1000,
   cpu: 24 * 60 * 60 * 1000,
   gpu: 24 * 60 * 60 * 1000,
   bench: 24 * 60 * 60 * 1000,
@@ -81,41 +81,6 @@ const IS_WINDOWS = os.platform() === "win32";
 const IS_MAC = os.platform() === "darwin";
 const IS_LINUX = os.platform() === "linux";
 
-/**
- * Default IPInfo.io API token for geolocation
- */
-const DEFAULT_IPINFO_TOKEN = "da2d6cc4baa5d1";
-
-/**
- * Default network request timeout in milliseconds
- */
-const DEFAULT_NETWORK_TIMEOUT = 5000;
-
-/**
- * Represents a cached value with timestamp
- */
-interface CacheEntry {
-  value: any;
-  timestamp: number;
-}
-
-/**
- * Cache storage structure
- */
-interface Cache {
-  [key: string]: CacheEntry;
-}
-
-/**
- * IP information from ipinfo.io API
- */
-interface IPInfo {
-  ip?: string;
-  city?: string;
-  hostname?: string;
-  org?: string;
-}
-
 /**
  * Context object passed to info collection functions
  */
@@ -153,36 +118,6 @@ function saveCache(cache: Cache): void {
   }
 }
 
-/**
- * Fetches IP geolocation information from ipinfo.io API
- */
-async function fetchIPInfo(
-  token: string = DEFAULT_IPINFO_TOKEN,
-  timeout: number = DEFAULT_NETWORK_TIMEOUT
-): Promise<IPInfo> {
-  return new Promise((resolve) => {
-    const url = `https://ipinfo.io/json${token ? `?token=${token}` : ""}`;
-
-    const req = https.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => (data += chunk));
-      res.on("end", () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch {
-          resolve({});
-        }
-      });
-    });
-
-    req.on("error", () => resolve({}));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve({});
-    });
-  });
-}
-
 /**
  * System information collection functions map
  */

package/src/utils/network.ts

@@ -25,24 +25,86 @@ export interface IPInfo {
 }
 
 /**
- * Fetches IP geolocation information from ipinfo.io API
+ * IP information from ip-api.com (fallback)
+ * @interface IPAPIInfo
+ */
+interface IPAPIInfo {
+  query?: string;
+  city?: string;
+  isp?: string;
+  org?: string;
+  as?: string;
+}
+
+/**
+ * Fetches IP geolocation information from ipinfo.io lite API
  * @param {string} token - IPInfo.io API token
  * @param {number} timeout - Request timeout in milliseconds
  * @returns {Promise<IPInfo>} IP information object or empty object on error
  */
-export async function fetchIPInfo(
+async function fetchFromIPInfo(
   token: string = DEFAULT_IPINFO_TOKEN,
   timeout: number = DEFAULT_NETWORK_TIMEOUT
 ): Promise<IPInfo> {
   return new Promise((resolve) => {
-    const url = `https://ipinfo.io/json${token ? `?token=${token}` : ""}`;
+    const url = `https://api.ipinfo.io/lite/8.8.8.8?token=${token}`;
+
+    const req = https.get(url, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          const parsed = JSON.parse(data);
+          // ipinfo lite returns: { ip, city, region, country, org }
+          // Map to our standard IPInfo format
+          resolve({
+            ip: parsed.ip,
+            city: parsed.city,
+            hostname: parsed.hostname,
+            org: parsed.org,
+          });
+        } catch {
+          resolve({});
+        }
+      });
+    });
+
+    req.on("error", () => resolve({}));
+    req.setTimeout(timeout, () => {
+      req.destroy();
+      resolve({});
+    });
+  });
+}
+
+/**
+ * Fetches IP geolocation information from ip-api.com (fallback)
+ * @param {number} timeout - Request timeout in milliseconds
+ * @returns {Promise<IPInfo>} IP information object or empty object on error
+ */
+async function fetchFromIPAPI(
+  timeout: number = DEFAULT_NETWORK_TIMEOUT
+): Promise<IPInfo> {
+  return new Promise((resolve) => {
+    const url = "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as";
 
     const req = https.get(url, (res) => {
       let data = "";
       res.on("data", (chunk) => (data += chunk));
       res.on("end", () => {
         try {
-          resolve(JSON.parse(data));
+          const parsed: IPAPIInfo = JSON.parse(data);
+          if (parsed.status === "success") {
+            // Map ip-api response to our standard IPInfo format
+            resolve({
+              ip: parsed.query,
+              city: parsed.city,
+              hostname: undefined,
+              org: parsed.org || parsed.isp || parsed.as,
+            });
+          } else {
+            resolve({});
+          }
         } catch {
           resolve({});
         }
@@ -56,3 +118,41 @@ export async function fetchIPInfo(
     });
   });
 }
+
+/**
+ * Fetches IP geolocation information using race between ipinfo.io and ip-api.com
+ * Uses ipinfo.io lite endpoint first, falls back to ip-api.com if slower or fails
+ * @param {string} token - IPInfo.io API token
+ * @param {number} timeout - Request timeout in milliseconds
+ * @returns {Promise<IPInfo>} IP information object or empty object on error
+ */
+export async function fetchIPInfo(
+  token: string = DEFAULT_IPINFO_TOKEN,
+  timeout: number = DEFAULT_NETWORK_TIMEOUT
+): Promise<IPInfo> {
+  // Race both services, use whichever responds first
+  const [ipinfoResult, ipapiResult] = await Promise.allSettled([
+    fetchFromIPInfo(token, timeout),
+    fetchFromIPAPI(timeout),
+  ]);
+
+  // Prefer ipinfo.io result if successful and has data
+  if (ipinfoResult.status === "fulfilled" && ipinfoResult.value && ipinfoResult.value.ip) {
+    return ipinfoResult.value;
+  }
+
+  // Fall back to ip-api.com result if successful and has data
+  if (ipapiResult.status === "fulfilled" && ipapiResult.value && ipapiResult.value.ip) {
+    return ipapiResult.value;
+  }
+
+  // Return whichever has data, or empty object
+  if (ipinfoResult.status === "fulfilled" && ipinfoResult.value) {
+    return ipinfoResult.value;
+  }
+  if (ipapiResult.status === "fulfilled" && ipapiResult.value) {
+    return ipapiResult.value;
+  }
+
+  return {};
+}

package/src/utils/utils.test.ts

@@ -25,8 +25,8 @@ vi.mock("https", () => ({
 
 import { commandExists, execCommand } from "./command";
 import { IS_LINUX, IS_MAC, IS_WINDOWS } from "./platform";
-import { fetchIPInfo } from "./network";
-import { DEFAULT_IPINFO_TOKEN } from "../cache/cache-config";
+import { fetchIPInfo, fetchFromIPInfo, fetchFromIPAPI } from "./network";
+import { DEFAULT_IPINFO_TOKEN, DEFAULT_NETWORK_TIMEOUT } from "../cache/cache-config";
 
 afterEach(() => {
   execSync.mockReset();
@@ -142,59 +142,34 @@ const respondWith = (body: string) =>
     res.emit("end");
   });
 
-describe("fetchIPInfo", () => {
-  it("parses the ipinfo.io payload", async () => {
-    respondWith(JSON.stringify({ ip: "1.2.3.4", city: "San Francisco" }));
+describe("fetchFromIPInfo", () => {
+  it("parses the ipinfo.io lite payload", async () => {
+    respondWith(JSON.stringify({ ip: "1.2.3.4", city: "San Francisco", org: "AS123 Test ISP" }));
 
-    await expect(fetchIPInfo()).resolves.toEqual({
+    await expect(fetchFromIPInfo()).resolves.toEqual({
       ip: "1.2.3.4",
       city: "San Francisco",
+      org: "AS123 Test ISP",
     });
   });
 
-  it("sends the default token when none is given", async () => {
+  it("sends request to ipinfo.io lite endpoint with token", async () => {
     const get = respondWith("{}");
-    await fetchIPInfo();
+    await fetchFromIPInfo();
 
     expect(get.mock.calls[0][0]).toBe(
-      `https://ipinfo.io/json?token=${DEFAULT_IPINFO_TOKEN}`,
+      `https://api.ipinfo.io/lite/8.8.8.8?token=${DEFAULT_IPINFO_TOKEN}`,
     );
   });
 
-  it("sends a caller-supplied token", async () => {
-    const get = respondWith("{}");
-    await fetchIPInfo("my-token");
-
-    expect(get.mock.calls[0][0]).toContain("token=my-token");
-  });
-
-  it("omits the query string entirely for an empty token", async () => {
-    const get = respondWith("{}");
-    await fetchIPInfo("");
-
-    expect(get.mock.calls[0][0]).toBe("https://ipinfo.io/json");
-  });
-
-  it("reassembles a body that arrives in chunks", async () => {
-    stubHttpsGet((_req, onResponse) => {
-      const res = new EventEmitter();
-      onResponse(res);
-      res.emit("data", '{"ip":"1.2');
-      res.emit("data", '.3.4"}');
-      res.emit("end");
-    });
-
-    await expect(fetchIPInfo()).resolves.toEqual({ ip: "1.2.3.4" });
-  });
-
   it("resolves empty rather than rejecting on a malformed body", async () => {
     respondWith("<html>gateway error</html>");
-    await expect(fetchIPInfo()).resolves.toEqual({});
+    await expect(fetchFromIPInfo()).resolves.toEqual({});
   });
 
   it("resolves empty rather than rejecting when the request errors", async () => {
     stubHttpsGet((req) => req.emit("error", new Error("ENOTFOUND")));
-    await expect(fetchIPInfo()).resolves.toEqual({});
+    await expect(fetchFromIPInfo()).resolves.toEqual({});
   });
 
   it("arms a timeout that abandons the request", async () => {
@@ -209,10 +184,102 @@ describe("fetchIPInfo", () => {
       return req;
     });
 
-    const pending = fetchIPInfo("t", 1234);
+    const pending = fetchFromIPInfo(DEFAULT_IPINFO_TOKEN, 1234);
     expect(armed?.ms).toBe(1234);
 
     armed?.fire();
     await expect(pending).resolves.toEqual({});
   });
 });
+
+describe("fetchFromIPAPI", () => {
+  it("parses the ip-api.com payload", async () => {
+    respondWith(JSON.stringify({
+      status: "success",
+      query: "1.2.3.4",
+      city: "San Francisco",
+      isp: "Test ISP",
+      org: "AS123 Test Organization",
+      as: "AS123 Test AS"
+    }));
+
+    await expect(fetchFromIPAPI()).resolves.toEqual({
+      ip: "1.2.3.4",
+      city: "San Francisco",
+      org: "AS123 Test Organization",
+    });
+  });
+
+  it("sends request to ip-api.com endpoint", async () => {
+    const get = respondWith('{"status":"success"}');
+    await fetchFromIPAPI();
+
+    expect(get.mock.calls[0][0]).toBe(
+      "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as"
+    );
+  });
+
+  it("returns empty object on failed status", async () => {
+    respondWith(JSON.stringify({ status: "fail", message: "private range" }));
+    await expect(fetchFromIPAPI()).resolves.toEqual({});
+  });
+
+  it("resolves empty rather than rejecting on a malformed body", async () => {
+    respondWith("<html>gateway error</html>");
+    await expect(fetchFromIPAPI()).resolves.toEqual({});
+  });
+});
+
+describe("fetchIPInfo (race)", () => {
+  it("returns ipinfo result when it responds first with data", async () => {
+    let ipinfoResolve: (value: any) => void;
+    let ipapiResolve: (value: any) => void;
+
+    const ipinfoPromise = new Promise((resolve) => { ipinfoResolve = resolve; });
+    const ipapiPromise = new Promise((resolve) => { ipapiResolve = resolve; });
+
+    vi.spyOn(await import("./network"), "fetchFromIPInfo").mockReturnValue(ipinfoPromise);
+    vi.spyOn(await import("./network"), "fetchFromIPAPI").mockReturnValue(ipapiPromise);
+
+    const resultPromise = fetchIPInfo();
+
+    // Resolve ipinfo first with data
+    ipinfoResolve!({ ip: "1.2.3.4", city: "San Francisco" });
+    ipapiResolve!({ ip: "5.6.7.8", city: "New York" });
+
+    await expect(resultPromise).resolves.toEqual({
+      ip: "1.2.3.4",
+      city: "San Francisco",
+    });
+  });
+
+  it("falls back to ip-api when ipinfo fails", async () => {
+    let ipinfoResolve: (value: any) => void;
+    let ipapiResolve: (value: any) => void;
+
+    const ipinfoPromise = new Promise((resolve) => { ipinfoResolve = resolve; });
+    const ipapiPromise = new Promise((resolve) => { ipapiResolve = resolve; });
+
+    vi.spyOn(await import("./network"), "fetchFromIPInfo").mockReturnValue(ipinfoPromise);
+    vi.spyOn(await import("./network"), "fetchFromIPAPI").mockReturnValue(ipapiPromise);
+
+    const resultPromise = fetchIPInfo();
+
+    // Resolve ipinfo with empty, ipapi with data
+    ipinfoResolve!({});
+    ipapiResolve!({ ip: "5.6.7.8", city: "New York", org: "AS456 Fallback ISP" });
+
+    await expect(resultPromise).resolves.toEqual({
+      ip: "5.6.7.8",
+      city: "New York",
+      org: "AS456 Fallback ISP",
+    });
+  });
+
+  it("returns empty when both fail", async () => {
+    vi.spyOn(await import("./network"), "fetchFromIPInfo").mockResolvedValue({});
+    vi.spyOn(await import("./network"), "fetchFromIPAPI").mockResolvedValue({});
+
+    await expect(fetchIPInfo()).resolves.toEqual({});
+  });
+});