uplink-cli 0.2.8 → 0.2.9

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.2.9 — 2026-08-31
+
+The menu's **My domains** now shows verified registration status (the same as `domains list --verify`) instead of "no expiry data" for zone/hosted entries. RDAP results are cached in `~/.uplink/rdap-cache.json` for 24 hours, so only the first open pays for the lookups.
+
 ## 0.2.8 — 2026-08-31
 
 `domains list` is now grouped by provider and honest about what it knows: cPanel entries show as **hosted** (a panel serving a site says nothing about ownership), registrar expiry dates in the past show as **EXPIRED**, and new **`--verify`** RDAP-checks every entry without registration data (DNS zones, hosted sites) to reveal lapsed domains. RDAP goes straight to each TLD registry via the IANA bootstrap, with a DNS-delegation fallback for registries that 404.

package/cli/src/subcommands/domains.ts

@@ -22,6 +22,7 @@ import {
   rdapRegistration,
   type RdapRegistration,
 } from "../utils/domain-availability";
+import { cachedRegistrations, storeRegistrations } from "../utils/rdap-cache";
 import { searchDomains } from "../utils/domain-search";
 import {
   createNamecheapAddFundsRequest,
@@ -140,9 +141,14 @@ function formatDay(date: Date): string {
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
-/** RDAP-check registration for domains whose source can't attest ownership. */
+/**
+ * RDAP-check registration for domains whose source can't attest ownership.
+ * Fresh results (24h) come from the local cache, so repeat runs are instant.
+ */
 async function verifyRegistrations(domains: string[]): Promise<Map<string, RdapRegistration>> {
-  const out = new Map<string, RdapRegistration>();
+  const unique = [...new Set(domains)];
+  const out = cachedRegistrations(unique);
+  const missing = unique.filter((domain) => !out.has(domain));
   const run = async (targets: string[], batchSize: number, pauseMs: number) => {
     for (let i = 0; i < targets.length; i += batchSize) {
       if (i > 0) await sleep(pauseMs);
@@ -150,13 +156,14 @@ async function verifyRegistrations(domains: string[]): Promise<Map<string, RdapR
       for (const result of results) out.set(result.domain, result);
     }
   };
-  await run([...new Set(domains)], 4, 400);
-  // rdap.org rate-limits bursts; give inconclusive lookups one slower retry.
+  await run(missing, 4, 400);
+  // Registries rate-limit bursts; give inconclusive lookups one slower retry.
   const inconclusive = [...out.values()].filter((r) => r.registered === null).map((r) => r.domain);
   if (inconclusive.length > 0) {
     await sleep(2000);
     await run(inconclusive, 2, 1000);
   }
+  if (missing.length > 0) storeRegistrations(out.values());
   return out;
 }
 
@@ -302,8 +309,8 @@ domainsCommand
         console.log("");
       }
       if (!opts.verify && domains.some((item) => !parseExpiry(item.expiresAt))) {
-        console.log("Entries without expiry come from DNS zones / hosted sites and may be lapsed.");
-        console.log("Check actual registration: uplink domains list --verify");
+        console.log("Entries without expiry come from DNS zones / hosted sites, which don't include");
+        console.log("registration data. Confirm each one: uplink domains list --verify");
       }
     } catch (error) {
       handleError(error, { json: opts.json });

package/cli/src/subcommands/menu/menus/domains.ts

@@ -58,7 +58,9 @@ export function buildDomainsMenu(deps: Deps): MenuChoice {
         label: "My domains",
         action: async () => {
           try {
-            const output = runCliCapture(["domains", "list"]);
+            // --verify resolves registration for zone/hosted entries; results
+            // are cached for a day, so only the first open is slow.
+            const output = runCliCapture(["domains", "list", "--verify"]);
             restoreRawMode();
             return output || "No domains. Connect a registrar first.";
           } catch (error) {

package/cli/src/utils/rdap-cache.ts

@@ -0,0 +1,75 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import type { RdapRegistration } from "./domain-availability";
+
+/**
+ * Registration status changes rarely, and registry RDAP lookups are slow in
+ * bulk. Cache results for a day so `domains list --verify` (and the menu's
+ * My domains view) is instant after the first check.
+ */
+
+const TTL_MS = 24 * 60 * 60 * 1000;
+
+type CacheEntry = {
+  registered: boolean | null;
+  expiresAt?: string;
+  detail?: string;
+  checkedAt: number;
+};
+
+type CacheFile = Record<string, CacheEntry>;
+
+function cachePath(): string {
+  return join(homedir(), ".uplink", "rdap-cache.json");
+}
+
+function loadCache(): CacheFile {
+  const path = cachePath();
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as CacheFile;
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export function cachedRegistrations(domains: string[]): Map<string, RdapRegistration> {
+  const cache = loadCache();
+  const now = Date.now();
+  const out = new Map<string, RdapRegistration>();
+  for (const domain of domains) {
+    const entry = cache[domain];
+    // Inconclusive results (registered === null) are never served from cache.
+    if (!entry || entry.registered === null || now - entry.checkedAt > TTL_MS) continue;
+    out.set(domain, {
+      domain,
+      registered: entry.registered,
+      ...(entry.expiresAt ? { expiresAt: entry.expiresAt } : {}),
+      ...(entry.detail ? { detail: entry.detail } : {}),
+    });
+  }
+  return out;
+}
+
+export function storeRegistrations(results: Iterable<RdapRegistration>): void {
+  const cache = loadCache();
+  const now = Date.now();
+  for (const result of results) {
+    if (result.registered === null) continue;
+    cache[result.domain] = {
+      registered: result.registered,
+      ...(result.expiresAt ? { expiresAt: result.expiresAt } : {}),
+      ...(result.detail ? { detail: result.detail } : {}),
+      checkedAt: now,
+    };
+  }
+  mkdirSync(join(homedir(), ".uplink"), { recursive: true });
+  writeFileSync(cachePath(), JSON.stringify(cache, null, 2), { encoding: "utf8", mode: 0o600 });
+  try {
+    chmodSync(cachePath(), 0o600);
+  } catch {
+    /* ignore */
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uplink-cli",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Software for agents — share localhost, host apps, and attach domains from the terminal. JSON-first CLI for Cursor, Claude, Codex, and Windsurf.",
   "keywords": [
     "ai-agents",