uplink-cli 0.1.38 → 0.1.39

package/cli/src/registrars/hostinger.ts

@@ -0,0 +1,106 @@
+import { httpError, parseJson } from "./http";
+import type { DomainQuote, InventoryDomain, RegistrarAdapter, RegistrarCredentials } from "./types";
+
+const BASE = "https://developers.hostinger.com";
+
+async function hostingerFetch(
+  creds: RegistrarCredentials,
+  path: string,
+  init: RequestInit = {}
+): Promise<Response> {
+  if (!creds.token) throw new Error("Hostinger token is missing");
+  return fetch(`${BASE}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${creds.token}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...(init.headers || {}),
+    },
+  });
+}
+
+function asList(data: unknown): unknown[] {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object") {
+    const obj = data as { data?: unknown; items?: unknown; domains?: unknown };
+    if (Array.isArray(obj.data)) return obj.data;
+    if (Array.isArray(obj.items)) return obj.items;
+    if (Array.isArray(obj.domains)) return obj.domains;
+  }
+  return [];
+}
+
+function domainField(item: unknown): string | undefined {
+  if (!item || typeof item !== "object") return undefined;
+  const obj = item as { domain?: string; name?: string; domain_name?: string };
+  return obj.domain || obj.name || obj.domain_name;
+}
+
+function splitDomain(fqdn: string): { label: string; tld: string } {
+  const i = fqdn.indexOf(".");
+  if (i <= 0) return { label: fqdn, tld: "com" };
+  return { label: fqdn.slice(0, i), tld: fqdn.slice(i + 1) };
+}
+
+export const hostingerAdapter: RegistrarAdapter = {
+  id: "hostinger",
+  label: "Hostinger",
+  connectHelp: "hPanel API token. --token-env HOSTINGER_API_TOKEN",
+  async verify(creds) {
+    const res = await hostingerFetch(creds, "/api/domains/v1/portfolio");
+    if (!res.ok) throw httpError(res, await res.text());
+    return creds;
+  },
+  async listDomains(creds) {
+    const res = await hostingerFetch(creds, "/api/domains/v1/portfolio");
+    if (!res.ok) throw httpError(res, await res.text());
+    const data = await parseJson<unknown>(res);
+    const out: InventoryDomain[] = [];
+    for (const item of asList(data)) {
+      const domain = domainField(item);
+      if (!domain) continue;
+      const expires =
+        item && typeof item === "object"
+          ? (item as { expires_at?: string; expiry_date?: string }).expires_at ||
+            (item as { expiry_date?: string }).expiry_date
+          : undefined;
+      out.push({
+        domain: domain.toLowerCase(),
+        provider: "hostinger",
+        status: "owned",
+        expiresAt: expires,
+      });
+    }
+    return out;
+  },
+  async check(creds, domain) {
+    const { label, tld } = splitDomain(domain);
+    const res = await hostingerFetch(creds, "/api/domains/v1/availability", {
+      method: "POST",
+      body: JSON.stringify({ domain: label, tlds: [tld], with_alternatives: false }),
+    });
+    if (!res.ok) throw httpError(res, await res.text());
+    const data = await parseJson<unknown>(res);
+    const rows = asList(data);
+    const match =
+      rows.find((row) => domainField(row)?.toLowerCase() === domain.toLowerCase()) || rows[0];
+    const available =
+      match && typeof match === "object"
+        ? Boolean((match as { is_available?: boolean; available?: boolean }).is_available ??
+            (match as { available?: boolean }).available)
+        : false;
+    if (available) {
+      return { domain, provider: "hostinger", status: "available", buyable: true };
+    }
+    const restriction =
+      match && typeof match === "object" ? (match as { restriction?: string }).restriction : undefined;
+    return {
+      domain,
+      provider: "hostinger",
+      status: restriction ? "not_for_sale" : "taken",
+      buyable: false,
+      error: restriction,
+    };
+  },
+};

package/cli/src/registrars/http.ts

@@ -0,0 +1,18 @@
+export async function readResponseBody(res: Response): Promise<string> {
+  return res.text();
+}
+
+export async function parseJson<T>(res: Response): Promise<T> {
+  const text = await readResponseBody(res);
+  if (!text) return {} as T;
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    throw new Error(`Invalid JSON from ${res.url} (${res.status})`);
+  }
+}
+
+export function httpError(res: Response, body: string): Error {
+  const trimmed = body.replace(/\s+/g, " ").trim().slice(0, 300);
+  return new Error(`HTTP ${res.status}${trimmed ? `: ${trimmed}` : ""}`);
+}

package/cli/src/registrars/index.ts

@@ -0,0 +1,30 @@
+import { cloudflareAdapter } from "./cloudflare";
+import { godaddyAdapter } from "./godaddy";
+import { hostingerAdapter } from "./hostinger";
+import { namecheapAdapter } from "./namecheap";
+import type { ProviderId, RegistrarAdapter } from "./types";
+
+/** GoDaddy first, then the rest. Namecheap last because connect is the clumsiest. */
+export const adapters: RegistrarAdapter[] = [
+  godaddyAdapter,
+  cloudflareAdapter,
+  hostingerAdapter,
+  namecheapAdapter,
+];
+
+const byId = new Map(adapters.map((adapter) => [adapter.id, adapter]));
+
+export function getAdapter(id: ProviderId): RegistrarAdapter {
+  const adapter = byId.get(id);
+  if (!adapter) throw new Error(`Unknown provider: ${id}`);
+  return adapter;
+}
+
+export { connectedProviders, readRegistrarStore, removeProvider, saveProvider } from "./store";
+export { PROVIDER_IDS, isProviderId } from "./types";
+export type {
+  DomainQuote,
+  InventoryDomain,
+  ProviderId,
+  RegistrarCredentials,
+} from "./types";

package/cli/src/registrars/namecheap.ts

@@ -0,0 +1,163 @@
+import { httpError } from "./http";
+import type { DomainQuote, InventoryDomain, RegistrarAdapter, RegistrarCredentials } from "./types";
+
+const API_URL = "https://api.namecheap.com/xml.response";
+
+let clientIpPromise: Promise<string> | undefined;
+const pricingCache = new Map<string, Promise<Map<string, number>>>();
+
+async function clientIp(): Promise<string> {
+  clientIpPromise ??= fetch("https://api.ipify.org")
+    .then(async (res) => {
+      if (!res.ok) throw new Error(`ip lookup failed (${res.status})`);
+      return (await res.text()).trim();
+    })
+    .catch((error: unknown) => {
+      clientIpPromise = undefined;
+      throw error;
+    });
+  return clientIpPromise;
+}
+
+function attr(tag: string, name: string): string | undefined {
+  return new RegExp(`${name}="([^"]*)"`, "i").exec(tag)?.[1];
+}
+
+async function namecheapCall(
+  creds: RegistrarCredentials,
+  command: string,
+  extra: Record<string, string>
+): Promise<string> {
+  if (!creds.apiUser || !creds.apiKey) throw new Error("Namecheap API user and key are required");
+  const params = new URLSearchParams({
+    ApiUser: creds.apiUser,
+    ApiKey: creds.apiKey,
+    UserName: creds.apiUser,
+    Command: command,
+    ClientIp: await clientIp(),
+    ...extra,
+  });
+  const res = await fetch(`${API_URL}?${params}`);
+  const xml = await res.text();
+  const status = /Status="([^"]+)"/.exec(xml)?.[1];
+  if (status !== "OK") {
+    const err = /<Error[^>]*>([^<]+)<\/Error>/.exec(xml)?.[1] || `Namecheap ${status || res.status}`;
+    const ip = await clientIp().catch(() => "");
+    if (/ip/i.test(err) && ip) {
+      throw new Error(`${err}. Whitelist this machine's IP in Namecheap API access: ${ip}`);
+    }
+    throw new Error(err);
+  }
+  if (!res.ok) throw httpError(res, xml);
+  return xml;
+}
+
+async function loadRegisterPrices(creds: RegistrarCredentials): Promise<Map<string, number>> {
+  const xml = await namecheapCall(creds, "namecheap.users.getPricing", {
+    ProductType: "DOMAIN",
+    ActionName: "REGISTER",
+  });
+  const prices = new Map<string, number>();
+  const categories = xml.matchAll(/<ProductCategory Name="register">([\s\S]*?)<\/ProductCategory>/gi);
+  for (const category of categories) {
+    const products = category[1].matchAll(/<Product Name="([^"]+)">([\s\S]*?)<\/Product>/gi);
+    for (const match of products) {
+      const tld = match[1].toLowerCase();
+      const year1 =
+        /<Price\b([^>]*Duration="1"[^>]*DurationType="YEAR"[^>]*)\/?>/i.exec(match[2]) ??
+        /<Price\b([^>]*DurationType="YEAR"[^>]*Duration="1"[^>]*)\/?>/i.exec(match[2]);
+      if (!year1) continue;
+      const fields = year1[1];
+      const your = Number(attr(fields, "YourPrice") ?? attr(fields, "Price"));
+      if (!Number.isFinite(your)) continue;
+      const extra = Number(attr(fields, "YourAdditonalCost") ?? attr(fields, "AdditionalCost") ?? "0");
+      prices.set(tld, your + (Number.isFinite(extra) ? extra : 0));
+    }
+  }
+  return prices;
+}
+
+function registerPrices(creds: RegistrarCredentials): Promise<Map<string, number>> {
+  const key = creds.apiUser || "";
+  let pending = pricingCache.get(key);
+  if (!pending) {
+    pending = loadRegisterPrices(creds).catch((error: unknown) => {
+      pricingCache.delete(key);
+      throw error;
+    });
+    pricingCache.set(key, pending);
+  }
+  return pending;
+}
+
+export const namecheapAdapter: RegistrarAdapter = {
+  id: "namecheap",
+  label: "Namecheap",
+  connectHelp:
+    "API key + username, and whitelist this machine's IP. --token-env NAMECHEAP_API_KEY --user-env NAMECHEAP_API_USER",
+  async verify(creds) {
+    await namecheapCall(creds, "namecheap.domains.getList", { PageSize: "20" });
+    return creds;
+  },
+  async listDomains(creds) {
+    const out: InventoryDomain[] = [];
+    let page = 1;
+    for (;;) {
+      const xml = await namecheapCall(creds, "namecheap.domains.getList", {
+        Page: String(page),
+        PageSize: "100",
+      });
+      const tags = xml.matchAll(/<Domain\b([^>]*)\/?>/gi);
+      let count = 0;
+      for (const match of tags) {
+        count += 1;
+        const name = attr(match[1], "Name") || attr(match[1], "Domain");
+        if (!name) continue;
+        out.push({
+          domain: name.toLowerCase(),
+          provider: "namecheap",
+          status: "owned",
+          expiresAt: attr(match[1], "Expires") || attr(match[1], "ExpiredDate"),
+        });
+      }
+      if (count < 100) break;
+      page += 1;
+      if (page > 50) break;
+    }
+    return out;
+  },
+  async check(creds, domain) {
+    const xml = await namecheapCall(creds, "namecheap.domains.check", { DomainList: domain });
+    const tag = xml.match(/<DomainCheckResult\b([^>]*)\/?>/i)?.[1];
+    if (!tag) {
+      return { domain, provider: "namecheap", status: "unknown", error: "no check result" };
+    }
+    const available = attr(tag, "Available")?.toLowerCase() === "true";
+    const premium = attr(tag, "IsPremiumName")?.toLowerCase() === "true";
+    if (!available) {
+      return { domain, provider: "namecheap", status: "not_for_sale", buyable: false, premium };
+    }
+    if (premium) {
+      const price =
+        Number(attr(tag, "PremiumRegistrationPrice") || "0") + Number(attr(tag, "IcannFee") || "0");
+      return {
+        domain,
+        provider: "namecheap",
+        status: "available",
+        buyable: true,
+        premium: true,
+        priceUsd: price > 0 ? price : undefined,
+      };
+    }
+    const tld = domain.slice(domain.lastIndexOf(".") + 1).toLowerCase();
+    const prices = await registerPrices(creds);
+    return {
+      domain,
+      provider: "namecheap",
+      status: "available",
+      buyable: true,
+      premium: false,
+      priceUsd: prices.get(tld),
+    };
+  },
+};

package/cli/src/registrars/secret.ts

@@ -0,0 +1,66 @@
+import { createInterface } from "readline";
+
+export function readEnvValue(name: string): string {
+  const value = process.env[name]?.trim();
+  if (!value) throw new Error(`Environment variable ${name} is empty or missing`);
+  return value;
+}
+
+/** Hidden prompt. Agents should use --token-env instead so the secret never hits argv. */
+export async function promptSecret(question: string): Promise<string> {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
+    const rl = createInterface({ input: stdin, output: stdout });
+    const answer = await new Promise<string>((resolve) => {
+      rl.question(question, (value) => {
+        rl.close();
+        resolve(value);
+      });
+    });
+    return answer.trim();
+  }
+
+  stdout.write(question);
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+
+  return new Promise((resolve, reject) => {
+    let value = "";
+    const onData = (chunk: string) => {
+      for (const char of chunk) {
+        if (char === "\n" || char === "\r") {
+          cleanup();
+          stdout.write("\n");
+          resolve(value.trim());
+          return;
+        }
+        if (char === "\u0003") {
+          cleanup();
+          stdout.write("\n");
+          reject(new Error("Cancelled"));
+          return;
+        }
+        if (char === "\u007f" || char === "\b") {
+          value = value.slice(0, -1);
+          continue;
+        }
+        if (char >= " ") value += char;
+      }
+    };
+    const cleanup = () => {
+      stdin.off("data", onData);
+      try {
+        stdin.setRawMode(false);
+      } catch {
+        /* ignore */
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+export function canPrompt(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}

package/cli/src/registrars/store.ts

@@ -0,0 +1,55 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import type { ProviderId, RegistrarCredentials } from "./types";
+
+export type RegistrarStore = Partial<Record<ProviderId, RegistrarCredentials>>;
+
+function storeDir(): string {
+  return join(homedir(), ".uplink");
+}
+
+export function registrarStorePath(): string {
+  return join(storeDir(), "registrars.json");
+}
+
+export function readRegistrarStore(): RegistrarStore {
+  const path = registrarStorePath();
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as RegistrarStore;
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeRegistrarStore(store: RegistrarStore): void {
+  mkdirSync(storeDir(), { recursive: true });
+  const path = registrarStorePath();
+  writeFileSync(path, JSON.stringify(store, null, 2), { encoding: "utf8", mode: 0o600 });
+  try {
+    chmodSync(path, 0o600);
+  } catch {
+    /* ignore */
+  }
+}
+
+export function saveProvider(id: ProviderId, creds: RegistrarCredentials): void {
+  const store = readRegistrarStore();
+  store[id] = creds;
+  writeRegistrarStore(store);
+}
+
+export function removeProvider(id: ProviderId): boolean {
+  const store = readRegistrarStore();
+  if (!store[id]) return false;
+  delete store[id];
+  writeRegistrarStore(store);
+  return true;
+}
+
+export function connectedProviders(): ProviderId[] {
+  const store = readRegistrarStore();
+  return (Object.keys(store) as ProviderId[]).filter((id) => Boolean(store[id]));
+}

package/cli/src/registrars/types.ts

@@ -0,0 +1,40 @@
+export const PROVIDER_IDS = ["godaddy", "cloudflare", "hostinger", "namecheap"] as const;
+export type ProviderId = (typeof PROVIDER_IDS)[number];
+
+export function isProviderId(value: string): value is ProviderId {
+  return (PROVIDER_IDS as readonly string[]).includes(value);
+}
+
+export type RegistrarCredentials = {
+  token?: string;
+  apiUser?: string;
+  apiKey?: string;
+  accountId?: string;
+};
+
+export type InventoryDomain = {
+  domain: string;
+  provider: ProviderId;
+  status: "owned";
+  expiresAt?: string;
+};
+
+export type DomainQuote = {
+  domain: string;
+  provider: ProviderId;
+  status: "owned" | "available" | "taken" | "not_for_sale" | "unknown";
+  buyable?: boolean;
+  priceUsd?: number;
+  premium?: boolean;
+  error?: string;
+};
+
+export type RegistrarAdapter = {
+  id: ProviderId;
+  label: string;
+  /** What an agent must pass to connect. */
+  connectHelp: string;
+  verify(creds: RegistrarCredentials): Promise<RegistrarCredentials>;
+  listDomains(creds: RegistrarCredentials): Promise<InventoryDomain[]>;
+  check(creds: RegistrarCredentials, domain: string): Promise<DomainQuote>;
+};

package/cli/src/subcommands/admin.ts

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { apiRequest } from "../http";
 import { getResolvedApiBase } from "../utils/api-base";
+import { handleError } from "../utils/machine";
 
 export const adminCommand = new Command("admin")
   .description("Admin commands for system management");
@@ -63,10 +64,8 @@ adminCommand
         console.log(`  Created 24h: ${stats.databases.createdLast24h}`);
         console.log();
       }
-    } catch (error: any) {
-      const errorMsg = error.message || error.toString() || JSON.stringify(error);
-      console.error("Error getting status:", errorMsg);
-      process.exit(1);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -118,10 +117,8 @@ adminCommand
         }
         console.log();
       }
-    } catch (error: any) {
-      const errorMsg = error.message || error.toString() || JSON.stringify(error);
-      console.error("Error listing tunnels:", errorMsg);
-      process.exit(1);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -176,10 +173,8 @@ adminCommand
         }
         console.log();
       }
-    } catch (error: any) {
-      const errorMsg = error.message || error.toString() || JSON.stringify(error);
-      console.error("Error listing databases:", errorMsg);
-      process.exit(1);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -222,10 +217,8 @@ tokensCommand
       console.log("\nIMPORTANT: This token is shown only once. Store it securely.\n");
       console.log(result.token);
       console.log();
-    } catch (error: any) {
-      const errorMsg = error.message || error.toString() || JSON.stringify(error);
-      console.error("Error creating token:", errorMsg);
-      process.exit(1);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -287,10 +280,8 @@ tokensCommand
         );
       }
       console.log();
-    } catch (error: any) {
-      const errorMsg = error.message || error.toString() || JSON.stringify(error);
-      console.error("Error listing tokens:", errorMsg);
-      process.exit(1);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -306,7 +297,7 @@ tokensCommand
       const token = opts.token ? String(opts.token) : "";
       if (!id && !token) {
         console.error("Provide --id or --token");
-        process.exit(1);
+        process.exit(2);
       }
 
       const result = await apiRequest("POST", "/v1/admin/tokens/revoke", {
@@ -319,10 +310,8 @@ tokensCommand
       } else {
         console.log(`✅ Revoked token${id ? ` ${id}` : ""} at ${result.revokedAt || ""}`);
       }
-    } catch (error: any) {
-      const errorMsg = error.message || error.toString() || JSON.stringify(error);
-      console.error("Error revoking token:", errorMsg);
-      process.exit(1);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -344,12 +333,10 @@ adminCommand
         }
       } else {
         console.error("Specify what to cleanup: --dev-user-tunnels");
-        process.exit(1);
+        process.exit(2);
       }
-    } catch (error: any) {
-      const errorMsg = error.message || error.toString() || JSON.stringify(error);
-      console.error("Error during cleanup:", errorMsg);
-      process.exit(1);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });