@gtld/whois 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 planetabhi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,8 @@
-# Temporary Holding Version
+# @gtld/whois
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Look up WHOIS and RDAP details for any domain, printed in a clean, scannable
+format in your terminal.
+
+```sh
+npx @gtld/whois example.com
+```

package/dist/cli.js

@@ -0,0 +1,477 @@
+#!/usr/bin/env node
+
+// package.json
+var package_default = {
+  name: "@gtld/whois",
+  version: "0.1.0",
+  description: "Scannable WHOIS/RDAP domain lookups in your terminal.",
+  type: "module",
+  bin: {
+    "gtld-whois": "dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=20.12"
+  },
+  scripts: {
+    dev: "tsx src/cli.ts",
+    build: "tsup",
+    test: "vitest run",
+    lint: "tsc --noEmit",
+    format: "prettier --write .",
+    pack: "npm run build && npm pack",
+    prepublishOnly: "npm run build && npm test"
+  },
+  keywords: [
+    "whois",
+    "rdap",
+    "domain",
+    "cli",
+    "dns",
+    "lookup"
+  ],
+  author: "@planetabhi",
+  license: "MIT",
+  homepage: "https://github.com/planetabhi/whois#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/planetabhi/whois.git"
+  },
+  bugs: {
+    url: "https://github.com/planetabhi/whois/issues"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  dependencies: {
+    "@clack/prompts": "^1.8.1"
+  },
+  devDependencies: {
+    "@types/node": "^26.6.5",
+    prettier: "^3.9.10",
+    tsup: "^9.0.0",
+    tsx: "^4.23.15",
+    typescript: "^7.0.2",
+    vitest: "^5.0.5"
+  }
+};
+
+// src/args.ts
+function parseArgs(argv) {
+  const parsed = {
+    json: false,
+    raw: false,
+    help: false,
+    version: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        parsed.help = true;
+        break;
+      case "-v":
+      case "--version":
+        parsed.version = true;
+        break;
+      case "--json":
+        parsed.json = true;
+        break;
+      case "--raw":
+        parsed.raw = true;
+        break;
+      case "--color":
+        parsed.color = true;
+        break;
+      case "--no-color":
+        parsed.color = false;
+        break;
+      case "--api":
+        parsed.apiBase = argv[++i];
+        break;
+      default:
+        if (arg.startsWith("--api=")) {
+          parsed.apiBase = arg.slice("--api=".length);
+        } else if (!arg.startsWith("-") && parsed.domain === void 0) {
+          parsed.domain = arg;
+        }
+        break;
+    }
+  }
+  return parsed;
+}
+function cleanDomain(input) {
+  return input.trim().toLowerCase().replace(/^[a-z]+:\/\//, "").replace(/\/.*$/, "").replace(/^www\./, "");
+}
+function looksLikeDomain(domain) {
+  return /^[^\s.]+(\.[^\s.]+)+$/.test(domain);
+}
+
+// src/api.ts
+var DEFAULT_API_BASE = "https://who-dat.as93.net";
+var WhoisError = class extends Error {
+  constructor(message, code, kind) {
+    super(message);
+    this.code = code;
+    this.kind = kind;
+    this.name = "WhoisError";
+  }
+  code;
+  kind;
+};
+function lookupUrl(domain, apiBase) {
+  const base = apiBase.replace(/\/+$/, "");
+  return new URL(`${base}/v1/whois/${encodeURIComponent(domain)}`);
+}
+async function request(url, signal) {
+  try {
+    return await fetch(url, {
+      headers: { accept: "application/json" },
+      signal
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new WhoisError("Request timed out.", "TIMEOUT", "network");
+    }
+    throw new WhoisError(
+      `Could not reach the API at ${url.origin}.`,
+      "NETWORK",
+      "network"
+    );
+  }
+}
+async function fetchWhois(domain, opts = {}) {
+  const apiBase = opts.apiBase ?? DEFAULT_API_BASE;
+  const res = await request(lookupUrl(domain, apiBase), opts.signal);
+  if (!res.ok) {
+    const body = await res.json().catch(() => null);
+    const detail = body?.error;
+    throw new WhoisError(
+      detail?.message ?? `Lookup failed (HTTP ${res.status}).`,
+      detail?.code ?? `HTTP_${res.status}`,
+      "api"
+    );
+  }
+  return await res.json();
+}
+async function fetchRaw(domain, opts = {}) {
+  const apiBase = opts.apiBase ?? DEFAULT_API_BASE;
+  const url = lookupUrl(domain, apiBase);
+  url.searchParams.set("raw", "true");
+  const res = await request(url, opts.signal);
+  if (!res.ok) {
+    const body = await res.json().catch(() => null);
+    const detail = body?.error;
+    throw new WhoisError(
+      detail?.message ?? `Lookup failed (HTTP ${res.status}).`,
+      detail?.code ?? `HTTP_${res.status}`,
+      "api"
+    );
+  }
+  return await res.text();
+}
+
+// src/render/format.ts
+function wrap(code, enabled) {
+  return (s) => enabled ? `\x1B[${code}m${s}\x1B[0m` : s;
+}
+function makeColors(enabled) {
+  return {
+    bold: wrap(1, enabled),
+    dim: wrap(2, enabled),
+    green: wrap(32, enabled),
+    yellow: wrap(33, enabled),
+    cyan: wrap(36, enabled)
+  };
+}
+var LABEL_WIDTH = 13;
+function row(label, value, c) {
+  return `  ${c.dim(label.padEnd(LABEL_WIDTH))}${value}`;
+}
+function subRow(label, value, c) {
+  return `    ${c.dim(label.padEnd(LABEL_WIDTH - 2))}${value}`;
+}
+function prettyStatus(status) {
+  const token = status.split(/\s+/)[0] ?? status;
+  return token.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase().trim();
+}
+function formatDate(iso) {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  return d.toISOString().slice(0, 10);
+}
+var UNITS = [
+  [31536e6, "year"],
+  [2592e6, "month"],
+  [864e5, "day"],
+  [36e5, "hour"],
+  [6e4, "minute"]
+];
+function relativeFromNow(iso) {
+  const then = new Date(iso).getTime();
+  if (Number.isNaN(then)) return "";
+  const diff = then - Date.now();
+  const abs = Math.abs(diff);
+  for (const [ms, name] of UNITS) {
+    const value = Math.floor(abs / ms);
+    if (value >= 1) {
+      const unit = value > 1 ? `${name}s` : name;
+      return diff > 0 ? `in ${value} ${unit}` : `${value} ${unit} ago`;
+    }
+  }
+  return "just now";
+}
+
+// src/render/sections.ts
+function header(r, c) {
+  const badge = r.isRegistered ? c.green("\u25CF registered") : c.yellow("\u25CB available");
+  const lines = [`  ${c.bold(r.domain)}  ${badge}`];
+  if (r.domainUnicode && r.domainUnicode !== r.domain) {
+    lines.push(`  ${c.dim(r.domainUnicode)}`);
+  }
+  return lines;
+}
+function overview(r, c) {
+  const lines = [];
+  if (r.registrar.name) lines.push(row("Registrar", r.registrar.name, c));
+  if (r.registrar.url) lines.push(row("URL", c.cyan(r.registrar.url), c));
+  if (r.registrar.abuseEmail) {
+    lines.push(row("Abuse", r.registrar.abuseEmail, c));
+  }
+  if (r.registrar.reseller)
+    lines.push(row("Reseller", r.registrar.reseller, c));
+  if (r.status.length > 0) {
+    lines.push(row("Status", r.status.map(prettyStatus).join(", "), c));
+  }
+  lines.push(
+    row("DNSSEC", r.dnssec.signed ? c.green("signed") : c.dim("unsigned"), c)
+  );
+  if (r.id) lines.push(row("Registry ID", r.id, c));
+  return lines;
+}
+function dates(r, c) {
+  const { created, updated, expires } = r.dates;
+  if (!created && !updated && !expires) return [];
+  const lines = [c.bold("  Dates")];
+  const add = (label, iso) => {
+    if (!iso) return;
+    const rel = relativeFromNow(iso);
+    lines.push(subRow(label, `${formatDate(iso)}   ${c.dim(`(${rel})`)}`, c));
+  };
+  add("Created", created);
+  add("Updated", updated);
+  add("Expires", expires);
+  return lines;
+}
+function nameservers(r, c) {
+  if (r.nameservers.length === 0) return [];
+  const lines = [c.bold("  Nameservers")];
+  for (const ns of r.nameservers) {
+    const ips = [...ns.ipv4, ...ns.ipv6];
+    const suffix = ips.length > 0 ? `  ${c.dim(ips.join(", "))}` : "";
+    lines.push(`    ${ns.name}${suffix}`);
+  }
+  return lines;
+}
+function contactLines(label, contact, c) {
+  if (contact.redacted) return [];
+  const parts = [];
+  const name = contact.name ?? contact.organization;
+  if (name) parts.push(name);
+  if (contact.email) parts.push(contact.email);
+  if (contact.phone) parts.push(contact.phone);
+  const loc = [contact.address.city, contact.address.country].filter(Boolean).join(", ");
+  if (loc) parts.push(loc);
+  if (parts.length === 0) return [];
+  return [subRow(label, parts.join(c.dim(" \xB7 ")), c)];
+}
+function contacts(r, c) {
+  const roles = [
+    ["Registrant", r.contacts.registrant],
+    ["Admin", r.contacts.admin],
+    ["Tech", r.contacts.tech],
+    ["Billing", r.contacts.billing]
+  ];
+  const body = roles.flatMap(
+    ([label, contact]) => contactLines(label, contact, c)
+  );
+  if (body.length === 0) return [];
+  return [c.bold("  Contacts"), ...body];
+}
+function meta(r, c) {
+  const bits = [r.meta.source];
+  if (r.meta.server) bits.push(r.meta.server);
+  bits.push(`fetched ${relativeFromNow(r.meta.fetchedAt) || "just now"}`);
+  if (r.meta.cached) bits.push("cached");
+  return [c.dim(`  ${bits.join(" \xB7 ")}`)];
+}
+
+// src/render/index.ts
+function renderResult(result, opts) {
+  const c = makeColors(opts.color);
+  const groups = [
+    header(result, c),
+    overview(result, c),
+    dates(result, c),
+    nameservers(result, c),
+    contacts(result, c),
+    meta(result, c)
+  ].filter((group) => group.length > 0);
+  return "\n" + groups.map((group) => group.join("\n")).join("\n\n") + "\n";
+}
+
+// src/ui.ts
+import {
+  intro,
+  outro,
+  spinner,
+  text,
+  isCancel,
+  cancel,
+  log
+} from "@clack/prompts";
+function isInteractive() {
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+function showIntro() {
+  intro("@gtld/whois");
+}
+function showOutro(message) {
+  outro(message ?? "Done");
+}
+async function promptDomain() {
+  const value = await text({
+    message: "Which domain do you want to look up?",
+    placeholder: "example.com",
+    validate(input) {
+      if (!input || input.trim().length === 0) return "Please enter a domain.";
+      return void 0;
+    }
+  });
+  if (isCancel(value)) {
+    cancel("Cancelled.");
+    process.exit(130);
+  }
+  return value;
+}
+function startSpinner(message, interactive) {
+  if (!interactive) {
+    return { stop: () => {
+    }, fail: () => {
+    } };
+  }
+  const s = spinner();
+  s.start(message);
+  return {
+    stop: (msg) => s.stop(msg),
+    fail: (msg) => s.stop(msg)
+  };
+}
+function logError(message) {
+  log.error(message);
+}
+
+// src/cli.ts
+var LOOKUP_TIMEOUT_MS = 15e3;
+var HELP = `
+@gtld/whois \u2014 beautiful WHOIS/RDAP lookups in your terminal
+
+Usage
+  npx @gtld/whois <domain> [options]
+
+Options
+  --json           Print the normalized JSON result
+  --raw            Print the raw upstream RDAP/WHOIS payload
+  --api <url>      Override the API base URL (env: GTLD_WHOIS_API)
+  --no-color       Disable ANSI colors
+  -h, --help       Show this help
+  -v, --version    Show the version
+
+Examples
+  npx @gtld/whois example.com
+  npx @gtld/whois example.com --json
+`;
+function resolveColor(args) {
+  if (args.color !== void 0) return args.color;
+  if (process.env.NO_COLOR) return false;
+  return Boolean(process.stdout.isTTY);
+}
+function exitCodeFor(err) {
+  return err.kind === "network" ? 2 : 1;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (args.version) {
+    process.stdout.write(`${package_default.version}
+`);
+    return 0;
+  }
+  const apiBase = args.apiBase ?? process.env.GTLD_WHOIS_API ?? DEFAULT_API_BASE;
+  const plain = args.json || args.raw;
+  const interactive = isInteractive() && !plain;
+  let rawInput = args.domain;
+  if (!rawInput) {
+    if (!interactive) {
+      logError("No domain provided. Usage: gtld-whois <domain>");
+      return 1;
+    }
+    showIntro();
+    rawInput = await promptDomain();
+  }
+  const domain = cleanDomain(rawInput);
+  if (!looksLikeDomain(domain)) {
+    logError(`"${rawInput}" doesn't look like a valid domain.`);
+    return 1;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), LOOKUP_TIMEOUT_MS);
+  const spin = startSpinner(`Looking up ${domain}\u2026`, interactive);
+  try {
+    if (args.raw) {
+      const body = await fetchRaw(domain, {
+        apiBase,
+        signal: controller.signal
+      });
+      spin.stop();
+      process.stdout.write(body.endsWith("\n") ? body : `${body}
+`);
+      return 0;
+    }
+    const result = await fetchWhois(domain, {
+      apiBase,
+      signal: controller.signal
+    });
+    spin.stop();
+    if (args.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+      return 0;
+    }
+    process.stdout.write(renderResult(result, { color: resolveColor(args) }));
+    if (interactive)
+      showOutro(result.isRegistered ? "Registered" : "Available");
+    return 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    spin.fail("Lookup failed");
+    logError(message);
+    return err instanceof WhoisError ? exitCodeFor(err) : 1;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+main().then(
+  (code) => process.exit(code),
+  (err) => {
+    process.stderr.write(`${err instanceof Error ? err.stack : String(err)}
+`);
+    process.exit(1);
+  }
+);

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@gtld/whois",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Scannable WHOIS/RDAP domain lookups in your terminal.",
+  "type": "module",
+  "bin": {
+    "gtld-whois": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.12"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "format": "prettier --write .",
+    "pack": "npm run build && npm pack",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "whois",
+    "rdap",
+    "domain",
+    "cli",
+    "dns",
+    "lookup"
+  ],
+  "author": "@planetabhi",
+  "license": "MIT",
+  "homepage": "https://github.com/planetabhi/whois#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/planetabhi/whois.git"
+  },
+  "bugs": {
+    "url": "https://github.com/planetabhi/whois/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "prettier": "^3.9.10",
+    "tsup": "^9.0.0",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.5"
+  }
+}