uplink-cli 0.2.6 → 0.2.8

package/AGENTS.md

@@ -127,6 +127,8 @@ uplink domains providers connect hostinger --token-env HOSTINGER_API_TOKEN --jso
 uplink domains providers connect dreamhost --token-env DREAMHOST_API_KEY --json
 uplink domains providers connect namecheap --token-env NAMECHEAP_API_KEY --user-env NAMECHEAP_API_USER --json
 uplink domains providers connect cpanel --host server341.web-hosting.com --user-env CPANEL_USER --token-env CPANEL_API_TOKEN --json
+# Repeat connect with another --host to add more cPanel accounts; remove one with:
+uplink domains providers disconnect cpanel --host server341.web-hosting.com --json
 uplink domains providers list --json
 uplink domains providers disconnect godaddy --json
 

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 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.
+
+## 0.2.7 — 2026-08-31
+
+Multiple **cPanel** accounts: `providers connect cpanel --host …` now appends (people have sites on several hosts), `providers disconnect cpanel --host …` removes one account, and `providers list` shows the connected hosts. One user, many shared hosts, one inventory.
+
 ## 0.2.6 — 2026-08-30
 
 Uplink as a **domain hub**: connect any **cPanel** host (Namecheap shared, Bluehost, HostGator, and most shared hosting) alongside registrars, so domains and sites scattered across providers land in one `domains list`. Connect with `uplink domains providers connect cpanel --host server.example.com --user-env CPANEL_USER --token-env CPANEL_API_TOKEN` (token from cPanel → Security → Manage API Tokens), or through the menu under Domains → Connect registrar.

package/cli/src/registrars/cpanel.ts

@@ -1,4 +1,9 @@
-import type { InventoryDomain, RegistrarAdapter, RegistrarCredentials } from "./types";
+import type {
+  CpanelAccount,
+  InventoryDomain,
+  RegistrarAdapter,
+  RegistrarCredentials,
+} from "./types";
 
 /**
  * cPanel is not a registrar, but it is where many people's sites actually
@@ -9,6 +14,9 @@ import type { InventoryDomain, RegistrarAdapter, RegistrarCredentials } from "./
  *
  * Auth: a cPanel API token (Security → Manage API Tokens in the panel),
  * sent as `Authorization: cpanel user:token` to the UAPI on port 2083.
+ *
+ * A user can connect several cPanel accounts (different hosts); each
+ * `providers connect cpanel --host …` appends to `creds.accounts`.
  */
 
 type UapiResponse = {
@@ -31,41 +39,65 @@ export function normalizeCpanelHost(raw: string): string {
   return host;
 }
 
-function baseUrl(creds: RegistrarCredentials): string {
-  const host = normalizeCpanelHost(creds.host || "");
+/** All connected cPanel accounts, including the legacy single-account shape. */
+export function cpanelAccountsOf(creds: RegistrarCredentials): CpanelAccount[] {
+  const accounts: CpanelAccount[] = [];
+  const push = (account: { host?: string; apiUser?: string; token?: string }) => {
+    if (!account.host || !account.apiUser || !account.token) return;
+    const host = normalizeCpanelHost(account.host);
+    if (accounts.some((a) => a.host === host && a.apiUser === account.apiUser)) return;
+    accounts.push({ host, apiUser: account.apiUser, token: account.token });
+  };
+  for (const account of creds.accounts || []) push(account);
+  push(creds);
+  return accounts;
+}
+
+/** Merge a newly verified account into stored creds (replace same host+user). */
+export function mergeCpanelCredentials(
+  existing: RegistrarCredentials | undefined,
+  incoming: RegistrarCredentials
+): RegistrarCredentials {
+  const merged: CpanelAccount[] = existing ? cpanelAccountsOf(existing) : [];
+  for (const account of cpanelAccountsOf(incoming)) {
+    const at = merged.findIndex((a) => a.host === account.host && a.apiUser === account.apiUser);
+    if (at >= 0) merged[at] = account;
+    else merged.push(account);
+  }
+  return { accounts: merged };
+}
+
+function baseUrl(host: string): string {
   return host.includes(":") ? `https://${host}` : `https://${host}:2083`;
 }
 
-async function uapi(creds: RegistrarCredentials, module: string, fn: string): Promise<unknown> {
-  const user = creds.apiUser || "";
-  const token = creds.token || "";
-  if (!user || !token) throw new Error("cPanel needs a username and an API token");
-  const url = `${baseUrl(creds)}/execute/${module}/${fn}`;
+async function uapi(account: CpanelAccount, module: string, fn: string): Promise<unknown> {
+  const url = `${baseUrl(account.host)}/execute/${module}/${fn}`;
   let res: Response;
   try {
     res = await fetch(url, {
       headers: {
-        Authorization: `cpanel ${user}:${token}`,
+        Authorization: `cpanel ${account.apiUser}:${account.token}`,
         Accept: "application/json",
       },
     });
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not reach cPanel at ${baseUrl(creds)} (${detail})`);
+    throw new Error(`Could not reach cPanel at ${baseUrl(account.host)} (${detail})`);
   }
   if (res.status === 401 || res.status === 403) {
-    throw new Error("cPanel rejected the credentials (check username and API token)");
+    throw new Error(`cPanel at ${account.host} rejected the credentials (check username and API token)`);
   }
   const text = await res.text();
   let body: UapiResponse;
   try {
     body = text ? (JSON.parse(text) as UapiResponse) : {};
   } catch {
-    throw new Error(`cPanel returned a non-JSON response (HTTP ${res.status})`);
+    throw new Error(`cPanel at ${account.host} returned a non-JSON response (HTTP ${res.status})`);
   }
   if (!res.ok || body.status !== 1) {
     const detail = body.errors?.filter(Boolean).join("; ") || `HTTP ${res.status}`;
-    throw new Error(`cPanel ${module}/${fn} failed: ${detail}`);
+    throw new Error(`cPanel ${module}/${fn} failed on ${account.host}: ${detail}`);
   }
   return body.data;
 }
@@ -75,20 +107,37 @@ function stringsOf(value: unknown): string[] {
   return value.filter((item): item is string => typeof item === "string" && item.includes("."));
 }
 
+async function listAccountDomains(account: CpanelAccount): Promise<string[]> {
+  const data = (await uapi(account, "DomainInfo", "list_domains")) as Record<string, unknown> | null;
+  const out: string[] = [];
+  const main = data?.main_domain;
+  if (typeof main === "string" && main.includes(".")) out.push(main);
+  out.push(...stringsOf(data?.addon_domains));
+  out.push(...stringsOf(data?.parked_domains));
+  return out;
+}
+
 async function listHostedDomains(creds: RegistrarCredentials): Promise<InventoryDomain[]> {
-  const data = (await uapi(creds, "DomainInfo", "list_domains")) as Record<string, unknown> | null;
+  const accounts = cpanelAccountsOf(creds);
+  if (accounts.length === 0) throw new Error("cPanel needs a host, username, and API token");
   const out: InventoryDomain[] = [];
   const seen = new Set<string>();
-  const push = (domain: string) => {
-    const normalized = domain.toLowerCase();
-    if (seen.has(normalized)) return;
-    seen.add(normalized);
-    out.push({ domain: normalized, provider: "cpanel", status: "owned" });
-  };
-  const main = data?.main_domain;
-  if (typeof main === "string" && main.includes(".")) push(main);
-  for (const domain of stringsOf(data?.addon_domains)) push(domain);
-  for (const domain of stringsOf(data?.parked_domains)) push(domain);
+  const errors: string[] = [];
+  for (const account of accounts) {
+    try {
+      for (const domain of await listAccountDomains(account)) {
+        const normalized = domain.toLowerCase();
+        if (seen.has(normalized)) continue;
+        seen.add(normalized);
+        // "hosted": the panel serves this domain; it says nothing about
+        // whether the registration is still owned.
+        out.push({ domain: normalized, provider: "cpanel", status: "hosted" });
+      }
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (out.length === 0 && errors.length > 0) throw new Error(errors.join("; "));
   return out;
 }
 
@@ -96,12 +145,18 @@ export const cpanelAdapter: RegistrarAdapter = {
   id: "cpanel",
   label: "cPanel hosting",
   connectHelp:
-    "Any cPanel host (Namecheap shared, Bluehost, HostGator, …). --host server.example.com --user-env CPANEL_USER --token-env CPANEL_API_TOKEN (token: cPanel → Security → Manage API Tokens)",
+    "Any cPanel host (Namecheap shared, Bluehost, HostGator, …). --host server.example.com --user-env CPANEL_USER --token-env CPANEL_API_TOKEN (token: cPanel → Security → Manage API Tokens). Repeat with another --host to add more accounts.",
   async verify(creds) {
-    if (!creds.host) throw new Error("cPanel needs --host (e.g. server341.web-hosting.com)");
-    creds.host = normalizeCpanelHost(creds.host);
-    await listHostedDomains(creds);
-    return creds;
+    // Verify only the incoming account(s); the connect flow merges them
+    // into any previously stored accounts afterwards.
+    const accounts = cpanelAccountsOf(creds);
+    if (accounts.length === 0) {
+      throw new Error("cPanel needs --host (e.g. server341.web-hosting.com), a username, and an API token");
+    }
+    for (const account of accounts) {
+      await listAccountDomains(account);
+    }
+    return { accounts };
   },
   async listDomains(creds) {
     const domains = await listHostedDomains(creds);
@@ -112,8 +167,8 @@ export const cpanelAdapter: RegistrarAdapter = {
     // domains, otherwise let the chain fall through to a registrar.
     const hosted = await listHostedDomains(creds);
     if (hosted.some((item) => item.domain === domain.toLowerCase())) {
-      return { domain, provider: "cpanel", status: "owned", buyable: false };
+      return { domain, provider: "cpanel", status: "taken", buyable: false };
     }
-    throw new Error("cPanel only knows domains hosted on the connected account");
+    throw new Error("cPanel only knows domains hosted on the connected accounts");
   },
 };

package/cli/src/registrars/types.ts

@@ -5,6 +5,12 @@ export function isProviderId(value: string): value is ProviderId {
   return (PROVIDER_IDS as readonly string[]).includes(value);
 }
 
+export type CpanelAccount = {
+  host: string;
+  apiUser: string;
+  token: string;
+};
+
 export type RegistrarCredentials = {
   token?: string;
   apiUser?: string;
@@ -14,12 +20,15 @@ export type RegistrarCredentials = {
   host?: string;
   /** Additional API keys for providers with multiple accounts (e.g. DreamHost). */
   extraTokens?: string[];
+  /** Multiple cPanel accounts — people often have sites on several hosts. */
+  accounts?: CpanelAccount[];
 };
 
 export type InventoryDomain = {
   domain: string;
   provider: ProviderId;
-  status: "owned";
+  /** "owned" = registrar registration; "hosted" = served by a panel (says nothing about ownership). */
+  status: "owned" | "hosted";
   expiresAt?: string;
 };
 

package/cli/src/subcommands/domains.ts

@@ -15,9 +15,12 @@ import {
   type RegistrarCredentials,
 } from "../registrars";
 import { canPrompt, promptSecret, readEnvValue } from "../registrars/secret";
+import { cpanelAccountsOf, mergeCpanelCredentials, normalizeCpanelHost } from "../registrars/cpanel";
 import {
   checkDomainAvailability,
   formatPublicAvailability,
+  rdapRegistration,
+  type RdapRegistration,
 } from "../utils/domain-availability";
 import { searchDomains } from "../utils/domain-search";
 import {
@@ -123,6 +126,60 @@ async function credentialsFromFlags(
   return creds;
 }
 
+/** Registrars report expiry in mixed formats (GoDaddy ISO, Namecheap MM/DD/YYYY). */
+function parseExpiry(value?: string): Date | undefined {
+  if (!value) return undefined;
+  const mdy = value.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+  const date = mdy ? new Date(`${mdy[3]}-${mdy[1]}-${mdy[2]}T00:00:00Z`) : new Date(value);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+}
+
+function formatDay(date: Date): string {
+  return date.toISOString().slice(0, 10);
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** RDAP-check registration for domains whose source can't attest ownership. */
+async function verifyRegistrations(domains: string[]): Promise<Map<string, RdapRegistration>> {
+  const out = new Map<string, RdapRegistration>();
+  const run = async (targets: string[], batchSize: number, pauseMs: number) => {
+    for (let i = 0; i < targets.length; i += batchSize) {
+      if (i > 0) await sleep(pauseMs);
+      const results = await Promise.all(targets.slice(i, i + batchSize).map(rdapRegistration));
+      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.
+  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);
+  }
+  return out;
+}
+
+function inventoryMarker(item: InventoryDomain, verified?: RdapRegistration): string {
+  const now = new Date();
+  if (verified) {
+    if (verified.registered === false) return "NOT REGISTERED — lapsed";
+    if (verified.registered === null) return `rdap inconclusive (${verified.detail})`;
+    const expiry = parseExpiry(verified.expiresAt);
+    if (expiry) {
+      return expiry < now
+        ? `registered · EXPIRED ${formatDay(expiry)} (rdap)`
+        : `registered · expires ${formatDay(expiry)} (rdap)`;
+    }
+    return verified.detail ? `registered · ${verified.detail}` : "registered (rdap)";
+  }
+  const expiry = parseExpiry(item.expiresAt);
+  if (expiry) {
+    return expiry < now ? `EXPIRED ${formatDay(expiry)}` : `expires ${formatDay(expiry)}`;
+  }
+  return item.status === "hosted" ? "hosted (ownership unknown)" : "no expiry data";
+}
+
 async function listInventory(providerFilter?: ProviderId): Promise<InventoryDomain[]> {
   const store = readRegistrarStore();
   const ids = providerFilter ? [providerFilter] : CHECK_ORDER.filter((id) => store[id]);
@@ -191,24 +248,62 @@ domainsCommand.action(() => {
 
 domainsCommand
   .command("list")
-  .description("List domains owned at connected registrars")
+  .description("Inventory across connected registrars and cPanel hosts, grouped by provider")
   .option("--provider <id>", "Only this provider (godaddy|cloudflare|hostinger|namecheap|dreamhost|cpanel)")
+  .option("--verify", "RDAP-check registration for entries without expiry data (zones/hosted sites)", false)
   .option("--json", "Output JSON", false)
   .action(async (opts) => {
     try {
       const provider = parseProvider(opts.provider);
       const domains = await listInventory(provider);
+
+      // Zones (DreamHost) and hosted sites (cPanel) carry no registration
+      // data — a lapsed domain can linger there forever. --verify asks RDAP.
+      let verified: Map<string, RdapRegistration> | undefined;
+      if (opts.verify) {
+        const unverifiable = domains.filter((item) => !parseExpiry(item.expiresAt));
+        verified = await verifyRegistrations(unverifiable.map((item) => item.domain));
+      }
+
       if (opts.json) {
-        printJson({ domains, count: domains.length });
+        const enriched = domains.map((item) => {
+          const check = verified?.get(item.domain);
+          return check
+            ? {
+                ...item,
+                registration: {
+                  registered: check.registered,
+                  ...(check.expiresAt ? { expiresAt: check.expiresAt } : {}),
+                  ...(check.detail ? { detail: check.detail } : {}),
+                },
+              }
+            : item;
+        });
+        printJson({ domains: enriched, count: enriched.length });
         return;
       }
+
       if (domains.length === 0) {
         console.log("No domains. Connect a registrar: uplink domains providers connect godaddy");
         return;
       }
+
+      const byProvider = new Map<ProviderId, InventoryDomain[]>();
       for (const item of domains) {
-        const expiry = item.expiresAt ? `  expires ${item.expiresAt}` : "";
-        console.log(`- ${item.domain} (${item.provider}${expiry})`);
+        const group = byProvider.get(item.provider) || [];
+        group.push(item);
+        byProvider.set(item.provider, group);
+      }
+      for (const [id, items] of byProvider) {
+        console.log(`${id} (${items.length})`);
+        for (const item of items) {
+          console.log(`  ${item.domain.padEnd(30)} ${inventoryMarker(item, verified?.get(item.domain))}`);
+        }
+        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");
       }
     } catch (error) {
       handleError(error, { json: opts.json });
@@ -569,18 +664,25 @@ providers
   .action((opts) => {
     try {
       const store = readRegistrarStore();
-      const items = adapters.map((adapter) => ({
-        id: adapter.id,
-        label: adapter.label,
-        connected: Boolean(store[adapter.id]),
-        help: adapter.connectHelp,
-      }));
+      const items = adapters.map((adapter) => {
+        const creds = store[adapter.id];
+        const cpanelHosts =
+          adapter.id === "cpanel" && creds ? cpanelAccountsOf(creds).map((a) => a.host) : undefined;
+        return {
+          id: adapter.id,
+          label: adapter.label,
+          connected: Boolean(creds),
+          ...(cpanelHosts ? { hosts: cpanelHosts } : {}),
+          help: adapter.connectHelp,
+        };
+      });
       if (opts.json) {
         printJson({ providers: items });
         return;
       }
       for (const item of items) {
-        console.log(`- ${item.id}  ${item.connected ? "connected" : "not connected"}`);
+        const hosts = item.hosts?.length ? ` (${item.hosts.join(", ")})` : "";
+        console.log(`- ${item.id}  ${item.connected ? `connected${hosts}` : "not connected"}`);
         if (!item.connected) console.log(`    ${item.help}`);
       }
     } catch (error) {
@@ -606,7 +708,13 @@ providers
       const adapter = getAdapter(provider);
       const creds = await credentialsFromFlags(provider, opts);
       const verified = await adapter.verify(creds);
-      saveProvider(provider, verified);
+      // cPanel accumulates accounts (people have sites on several hosts);
+      // other providers replace the stored credential.
+      const toSave =
+        provider === "cpanel"
+          ? mergeCpanelCredentials(readRegistrarStore().cpanel, verified)
+          : verified;
+      saveProvider(provider, toSave);
       const listed = await adapter.listDomains(verified).catch(() => [] as InventoryDomain[]);
       if (opts.json) {
         printJson({
@@ -626,11 +734,28 @@ providers
   .command("disconnect")
   .description("Remove a saved registrar or cPanel credential")
   .argument("<provider>", "godaddy | cloudflare | hostinger | namecheap | dreamhost | cpanel")
+  .option("--host <hostname>", "cPanel only: remove just this host's account")
   .option("--json", "Output JSON", false)
   .action((providerArg: string, opts) => {
     try {
       const provider = String(providerArg).toLowerCase();
       if (!isProviderId(provider)) throw new Error(`Unknown provider: ${providerArg}`);
+
+      if (provider === "cpanel" && opts.host) {
+        const host = normalizeCpanelHost(String(opts.host));
+        const existing = readRegistrarStore().cpanel;
+        const accounts = existing ? cpanelAccountsOf(existing).filter((a) => a.host !== host) : [];
+        const removed = existing ? cpanelAccountsOf(existing).length !== accounts.length : false;
+        if (accounts.length === 0) removeProvider(provider);
+        else saveProvider(provider, { accounts });
+        if (opts.json) {
+          printJson({ provider, host, removed, remainingAccounts: accounts.length });
+          return;
+        }
+        console.log(removed ? `Removed cPanel account on ${host}` : `No cPanel account on ${host}`);
+        return;
+      }
+
       const removed = removeProvider(provider);
       if (opts.json) {
         printJson({ provider, connected: false, removed });

package/cli/src/utils/domain-availability.ts

@@ -46,6 +46,87 @@ export async function checkDomainAvailability(domain: string): Promise<PublicAva
   return { domain, status: "unknown", source: "rdap", detail: lastFailure };
 }
 
+export type RdapRegistration = {
+  domain: string;
+  /** null = RDAP unreachable / inconclusive. */
+  registered: boolean | null;
+  expiresAt?: string;
+  detail?: string;
+};
+
+/**
+ * IANA RDAP bootstrap: maps a TLD to its authoritative registry RDAP base.
+ * Querying registries directly avoids the rdap.org aggregator's tight rate
+ * limits when verifying many domains.
+ */
+let rdapBootstrap: Map<string, string> | null = null;
+
+async function rdapBaseFor(domain: string): Promise<string> {
+  const tld = domain.slice(domain.lastIndexOf(".") + 1).toLowerCase();
+  if (!rdapBootstrap) {
+    rdapBootstrap = new Map();
+    try {
+      const response = await fetch("https://data.iana.org/rdap/dns.json", {
+        timeout: RDAP_TIMEOUT_MS,
+      });
+      if (response.ok) {
+        const body = (await response.json()) as { services?: Array<[string[], string[]]> };
+        for (const [tlds, urls] of body.services || []) {
+          const url = urls.find((u) => u.startsWith("https://")) || urls[0];
+          if (!url) continue;
+          const base = url.endsWith("/") ? url : `${url}/`;
+          for (const t of tlds) rdapBootstrap.set(t.toLowerCase(), base);
+        }
+      }
+    } catch {
+      // Bootstrap unavailable — fall back to the aggregator for everything.
+    }
+  }
+  const base = rdapBootstrap.get(tld);
+  return base ? `${base}domain/` : "https://rdap.org/domain/";
+}
+
+/**
+ * Authoritative registration lookup via RDAP: is the domain registered at
+ * all, and when does the registration expire? Used to audit inventory
+ * entries whose source (DNS zones, cPanel) says nothing about ownership.
+ */
+export async function rdapRegistration(domain: string): Promise<RdapRegistration> {
+  try {
+    const response = await fetch(`${await rdapBaseFor(domain)}${encodeURIComponent(domain)}`, {
+      headers: { accept: "application/rdap+json" },
+      timeout: RDAP_TIMEOUT_MS,
+    });
+    if (response.status === 404) {
+      // Some registries 404 on rdap.org for registered domains. A domain
+      // that is delegated in public DNS is registered regardless.
+      try {
+        const nameservers = await dns.resolveNs(domain);
+        if (nameservers.length > 0) {
+          return { domain, registered: true, detail: "delegated in DNS (no RDAP record)" };
+        }
+      } catch {
+        // NXDOMAIN — the 404 stands.
+      }
+      return { domain, registered: false, detail: "no registration record" };
+    }
+    if (!response.ok) {
+      return { domain, registered: null, detail: `RDAP returned ${response.status}` };
+    }
+    const body = (await response.json()) as {
+      events?: Array<{ eventAction?: string; eventDate?: string }>;
+    };
+    const expiration = body.events?.find((e) => e.eventAction === "expiration")?.eventDate;
+    return { domain, registered: true, expiresAt: expiration };
+  } catch (error) {
+    return {
+      domain,
+      registered: null,
+      detail: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 export function formatPublicAvailability(result: PublicAvailability): string {
   const lines = [`${result.domain}  ${result.status}  (${result.detail})`];
   if (result.status === "available") {

package/docs/AGENTS.md

@@ -127,6 +127,8 @@ uplink domains providers connect hostinger --token-env HOSTINGER_API_TOKEN --jso
 uplink domains providers connect dreamhost --token-env DREAMHOST_API_KEY --json
 uplink domains providers connect namecheap --token-env NAMECHEAP_API_KEY --user-env NAMECHEAP_API_USER --json
 uplink domains providers connect cpanel --host server341.web-hosting.com --user-env CPANEL_USER --token-env CPANEL_API_TOKEN --json
+# Repeat connect with another --host to add more cPanel accounts; remove one with:
+uplink domains providers disconnect cpanel --host server341.web-hosting.com --json
 uplink domains providers list --json
 uplink domains providers disconnect godaddy --json
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uplink-cli",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "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",