about-system 0.10.9 → 0.10.11

package/src/utils/network.ts

@@ -3,6 +3,7 @@
  * @module network
  */
 
+import http from "http";
 import https from "https";
 import {
   DEFAULT_IPINFO_TOKEN,
@@ -25,34 +26,152 @@ export interface IPInfo {
 }
 
 /**
- * Fetches IP geolocation information from ipinfo.io API
+ * IP information from ip-api.com (fallback)
+ * @interface IPAPIInfo
+ */
+interface IPAPIInfo {
+  status?: string;
+  query?: string;
+  city?: string;
+  isp?: string;
+  org?: string;
+  as?: string;
+}
+
+/**
+ * GETs a URL and parses the body as JSON. Never rejects: resolves `null` on
+ * any error, on abort, or once `timeout` ms have passed in total — a hard
+ * deadline for the whole request, not a socket-idle timeout.
+ */
+function getJSON(
+  url: string,
+  timeout: number,
+  signal?: AbortSignal
+): Promise<any> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve(null);
+
+    let settled = false;
+    let req: http.ClientRequest | undefined;
+    const finish = (value: any) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve(value);
+    };
+    const onAbort = () => {
+      req?.destroy();
+      finish(null);
+    };
+    const timer = setTimeout(onAbort, timeout);
+    signal?.addEventListener("abort", onAbort);
+
+    try {
+      const get = url.startsWith("https:") ? https.get : http.get;
+      req = get(url, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            finish(JSON.parse(data));
+          } catch {
+            finish(null);
+          }
+        });
+        res.on("error", () => finish(null));
+      });
+      req.on("error", () => finish(null));
+    } catch {
+      finish(null);
+    }
+  });
+}
+
+/**
+ * Fetches IP information for this machine from the ipinfo.io lite API
+ * @param {string} token - IPInfo.io API token
+ * @param {number} timeout - Total request deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons the request when aborted
+ * @returns {Promise<IPInfo>} IP information object or empty object on error
+ */
+export async function fetchFromIPInfo(
+  token: string = DEFAULT_IPINFO_TOKEN,
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
+): Promise<IPInfo> {
+  const parsed = await getJSON(
+    `https://api.ipinfo.io/lite/me?token=${token}`,
+    timeout,
+    signal
+  );
+  if (!parsed || typeof parsed !== "object") return {};
+  // ipinfo lite returns { ip, asn, as_name, country, ... } — no city.
+  const org =
+    parsed.org ?? (parsed.asn && parsed.as_name ? `${parsed.asn} ${parsed.as_name}` : undefined);
+  return {
+    ip: parsed.ip,
+    city: parsed.city,
+    hostname: parsed.hostname,
+    org,
+  };
+}
+
+/**
+ * Fetches IP geolocation information from ip-api.com (fallback). The free
+ * tier is plain HTTP only.
+ * @param {number} timeout - Total request deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons the request when aborted
+ * @returns {Promise<IPInfo>} IP information object or empty object on error
+ */
+export async function fetchFromIPAPI(
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
+): Promise<IPInfo> {
+  const parsed: IPAPIInfo | null = await getJSON(
+    "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as",
+    timeout,
+    signal
+  );
+  if (!parsed || parsed.status !== "success") return {};
+  return {
+    ip: parsed.query,
+    city: parsed.city,
+    hostname: undefined,
+    org: parsed.org || parsed.isp || parsed.as,
+  };
+}
+
+/**
+ * Fetches IP information from ipinfo.io and ip-api.com in parallel and merges
+ * them: ipinfo.io wins per field, ip-api.com fills the gaps (ipinfo lite has
+ * no city). Both requests share the same deadline, so this never takes longer
+ * than `timeout`.
  * @param {string} token - IPInfo.io API token
- * @param {number} timeout - Request timeout in milliseconds
+ * @param {number} timeout - Total deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons both requests when aborted
  * @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
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
 ): 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({});
-        }
-      });
-    });
+  const [ipinfo, ipapi] = await Promise.all([
+    fetchFromIPInfo(token, timeout, signal),
+    fetchFromIPAPI(timeout, signal),
+  ]);
 
-    req.on("error", () => resolve({}));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve({});
-    });
-  });
+  const merged: IPInfo = {};
+  for (const source of [ipapi, ipinfo]) {
+    for (const [key, value] of Object.entries(source)) {
+      if (value) merged[key as keyof IPInfo] = value;
+    }
+  }
+  // ipinfo answers over IPv6 when the machine has it; the short IPv4 address
+  // reads better in a one-line greeting, so keep ip-api's when it has one.
+  if (merged.ip?.includes(":") && ipapi.ip && !ipapi.ip.includes(":")) {
+    merged.ip = ipapi.ip;
+  }
+  return merged;
 }

package/src/utils/utils.test.ts

@@ -22,16 +22,23 @@ vi.mock("https", () => ({
   get: httpsGet,
   default: { get: httpsGet },
 }));
+const httpGet = vi.hoisted(() => vi.fn());
+vi.mock("http", () => ({
+  get: httpGet,
+  default: { get: httpGet },
+}));
 
 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();
   httpsGet.mockReset();
+  httpGet.mockReset();
   vi.restoreAllMocks();
+  vi.useRealTimers();
 });
 
 describe("platform flags", () => {
@@ -118,101 +125,170 @@ describe("commandExists", () => {
   });
 });
 
-/** A fake `https.get` whose response body and failure mode a test controls. */
-function stubHttpsGet(behavior: (req: EventEmitter & { setTimeout: (ms: number, fn: () => void) => void; destroy: () => void }, onResponse: (res: EventEmitter) => void) => void) {
-  httpsGet.mockImplementation(
-    (_url: string, callback: (res: EventEmitter) => void) => {
-      const req = Object.assign(new EventEmitter(), {
-        setTimeout: vi.fn(),
-        destroy: vi.fn(),
-      });
-      queueMicrotask(() => behavior(req, callback));
-      return req;
-    },
-  );
-  return httpsGet;
+type FakeReq = EventEmitter & { destroy: () => void };
+
+/**
+ * A fake `get` (https or http) whose response a test controls. `behavior`
+ * runs on the next microtask; leave it empty to simulate a hung request.
+ */
+function stubGet(
+  get: typeof httpsGet,
+  behavior: (req: FakeReq, onResponse: (res: EventEmitter) => void) => void = () => {},
+) {
+  get.mockImplementation((_url: string, callback: (res: EventEmitter) => void) => {
+    const req: FakeReq = Object.assign(new EventEmitter(), { destroy: vi.fn() });
+    queueMicrotask(() => behavior(req, callback));
+    return req;
+  });
+  return get;
 }
 
 /** Emits a complete response body on the next tick. */
-const respondWith = (body: string) =>
-  stubHttpsGet((_req, onResponse) => {
+const respondWith = (get: typeof httpsGet, body: string) =>
+  stubGet(get, (_req, onResponse) => {
     const res = new EventEmitter();
     onResponse(res);
     res.emit("data", body);
     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(httpsGet, JSON.stringify({ ip: "1.2.3.4", asn: "AS123", as_name: "Test ISP", country: "US" }));
 
-    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 () => {
-    const get = respondWith("{}");
-    await fetchIPInfo();
+  it("asks about this machine, not a fixed address", async () => {
+    const get = respondWith(httpsGet, "{}");
+    await fetchFromIPInfo();
 
     expect(get.mock.calls[0][0]).toBe(
-      `https://ipinfo.io/json?token=${DEFAULT_IPINFO_TOKEN}`,
+      `https://api.ipinfo.io/lite/me?token=${DEFAULT_IPINFO_TOKEN}`,
     );
   });
 
-  it("sends a caller-supplied token", async () => {
-    const get = respondWith("{}");
-    await fetchIPInfo("my-token");
+  it("resolves empty rather than rejecting on a malformed body", async () => {
+    respondWith(httpsGet, "<html>gateway error</html>");
+    await expect(fetchFromIPInfo()).resolves.toEqual({});
+  });
 
-    expect(get.mock.calls[0][0]).toContain("token=my-token");
+  it("resolves empty rather than rejecting when the request errors", async () => {
+    stubGet(httpsGet, (req) => req.emit("error", new Error("ENOTFOUND")));
+    await expect(fetchFromIPInfo()).resolves.toEqual({});
   });
 
-  it("omits the query string entirely for an empty token", async () => {
-    const get = respondWith("{}");
-    await fetchIPInfo("");
+  it("gives up after a hard 3 second deadline by default", async () => {
+    vi.useFakeTimers();
+    stubGet(httpsGet);
+    let done = false;
+    const pending = fetchFromIPInfo().then((r) => ((done = true), r));
 
-    expect(get.mock.calls[0][0]).toBe("https://ipinfo.io/json");
+    await vi.advanceTimersByTimeAsync(DEFAULT_NETWORK_TIMEOUT - 1);
+    expect(done).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(pending).resolves.toEqual({});
+    expect(DEFAULT_NETWORK_TIMEOUT).toBe(3000);
+    expect(httpsGet.mock.results[0].value.destroy).toHaveBeenCalled();
   });
 
-  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");
+  it("abandons the request when the signal aborts", async () => {
+    stubGet(httpsGet);
+    const controller = new AbortController();
+    const pending = fetchFromIPInfo(DEFAULT_IPINFO_TOKEN, 60_000, controller.signal);
+
+    controller.abort();
+    await expect(pending).resolves.toEqual({});
+    expect(httpsGet.mock.results[0].value.destroy).toHaveBeenCalled();
+  });
+});
+
+describe("fetchFromIPAPI", () => {
+  it("parses the ip-api.com payload", async () => {
+    respondWith(httpGet, 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("uses plain http, which is all ip-api.com's free tier serves", async () => {
+    const get = respondWith(httpGet, '{"status":"success"}');
+    await fetchFromIPAPI();
 
-    await expect(fetchIPInfo()).resolves.toEqual({ ip: "1.2.3.4" });
+    expect(get.mock.calls[0][0]).toBe(
+      "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as"
+    );
+    expect(httpsGet).not.toHaveBeenCalled();
+  });
+
+  it("returns empty object on failed status", async () => {
+    respondWith(httpGet, 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(fetchIPInfo()).resolves.toEqual({});
+    respondWith(httpGet, "<html>gateway error</html>");
+    await expect(fetchFromIPAPI()).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({});
+describe("fetchIPInfo", () => {
+  it("prefers ipinfo per field and fills gaps from ip-api", async () => {
+    respondWith(httpsGet, JSON.stringify({ ip: "1.2.3.4", asn: "AS123", as_name: "Primary ISP" }));
+    respondWith(httpGet, JSON.stringify({ status: "success", query: "5.6.7.8", city: "New York", org: "AS456 Other" }));
+
+    await expect(fetchIPInfo()).resolves.toEqual({
+      ip: "1.2.3.4",
+      city: "New York",
+      org: "AS123 Primary ISP",
+    });
+  });
+
+  it("prefers an IPv4 address over ipinfo's IPv6 one", async () => {
+    respondWith(httpsGet, JSON.stringify({ ip: "2600:1010::1", asn: "AS123", as_name: "Primary ISP" }));
+    respondWith(httpGet, JSON.stringify({ status: "success", query: "5.6.7.8", city: "New York" }));
+
+    await expect(fetchIPInfo()).resolves.toMatchObject({ ip: "5.6.7.8" });
   });
 
-  it("arms a timeout that abandons the request", async () => {
-    let armed: { ms: number; fire: () => void } | undefined;
-    httpsGet.mockImplementation(() => {
-      const req = Object.assign(new EventEmitter(), {
-        setTimeout: (ms: number, fire: () => void) => {
-          armed = { ms, fire };
-        },
-        destroy: vi.fn(),
-      });
-      return req;
+  it("falls back to ip-api when ipinfo fails", async () => {
+    stubGet(httpsGet, (req) => req.emit("error", new Error("ECONNRESET")));
+    respondWith(httpGet, JSON.stringify({ status: "success", query: "5.6.7.8", city: "New York", org: "AS456 Fallback ISP" }));
+
+    await expect(fetchIPInfo()).resolves.toEqual({
+      ip: "5.6.7.8",
+      city: "New York",
+      org: "AS456 Fallback ISP",
     });
+  });
+
+  it("returns empty when both fail", async () => {
+    stubGet(httpsGet, (req) => req.emit("error", new Error("ENOTFOUND")));
+    stubGet(httpGet, (req) => req.emit("error", new Error("ENOTFOUND")));
+
+    await expect(fetchIPInfo()).resolves.toEqual({});
+  });
 
-    const pending = fetchIPInfo("t", 1234);
-    expect(armed?.ms).toBe(1234);
+  it("never waits past the shared deadline when both hang", async () => {
+    vi.useFakeTimers();
+    stubGet(httpsGet);
+    stubGet(httpGet);
+    const pending = fetchIPInfo();
 
-    armed?.fire();
+    await vi.advanceTimersByTimeAsync(DEFAULT_NETWORK_TIMEOUT);
     await expect(pending).resolves.toEqual({});
   });
 });