whoispk 2.0.0 → 2.1.0

package/README.md

@@ -27,6 +27,12 @@ npx whoispk yourbrand
 
 `.pk` is added for you. `yourbrand`, `yourbrand.pk` and `https://www.yourbrand.pk/` all look up the same domain, and `.com.pk`, `.org.pk` and the other second-level names work too.
 
+To check a name under every extension at once:
+
+```sh
+npx whoispk --all yourbrand
+```
+
 To have the `whoispk` command always available:
 
 ```sh
@@ -36,6 +42,7 @@ npm install -g whoispk
 ## Features
 
 - **Clear answers.** Each domain is registered, available, or not registrable. For a name PKNIC rejects, you get its reason.
+- **Every extension at once.** `--all` checks a name under `.pk`, `.com.pk`, `.net.pk`, `.org.pk`, `.biz.pk`, `.web.pk` and `.fam.pk`, one line each.
 - **Many domains at once.** Pass several names, or pipe in a list. Lookups run in parallel and print in your order.
 - **Made for scripts.** `--json` output, exit codes you can rely on, and no spinner in piped output.
 - **Also a library.** A promise-based API with TypeScript types, timeouts, retries and cancelling.
@@ -44,6 +51,16 @@ npm install -g whoispk
 
 ## Recipes
 
+**Find a free name** across every extension for a few ideas:
+
+```console
+$ whoispk --all chaiwala dhaba
+chaiwala.pk      ● Registered       expires Mar 20, 2027
+chaiwala.com.pk  ● Registered       expires Oct 10, 2030
+chaiwala.net.pk  ● Available
+…
+```
+
 **Check a shortlist of name ideas**, one per line (`#` starts a comment):
 
 ```sh
@@ -77,6 +94,8 @@ for (const name of ['mybrand.pk', 'mybrand.com.pk']) {
 ```
 whoispk [options] <domain...>
 
+  -a, --all              Check every public extension (.pk, .com.pk, .net.pk, …)
+  -s, --short            One line per domain (default with --all)
   -j, --json             Print results as JSON
   -t, --timeout <ms>     Per-request timeout (default: 15000)
   -c, --concurrency <n>  Parallel lookups (default: 3)

package/bin/whoispk.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { readFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
-import { lookup, ENDPOINT } from '../src/index.js';
+import { lookup, normalizeDomain, expandExtensions, EXTENSIONS, ENDPOINT } from '../src/index.js';
 
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
@@ -14,12 +14,19 @@ Check whether .pk domains are registered, using PKNIC's public lookup.
 Domains can also be piped in, one per line: cat domains.txt | whoispk
 
 Options:
-  -j, --json           Print results as JSON
-  -t, --timeout <ms>   Per-request timeout in milliseconds (default: 15000)
+  -a, --all              Check every public extension: ${EXTENSIONS.map((e) => '.' + e).join(' ')}
+  -s, --short            One line per domain (the default with --all; --no-short for details)
+  -j, --json             Print results as JSON
+  -t, --timeout <ms>     Per-request timeout in milliseconds (default: 15000)
   -c, --concurrency <n>  Parallel lookups when checking several domains (default: 3)
-      --no-color       Disable colours (also respects NO_COLOR)
-  -v, --version        Print the version
-  -h, --help           Show this help
+      --no-color         Disable colours (also respects NO_COLOR)
+  -v, --version          Print the version
+  -h, --help             Show this help
+
+Examples:
+  whoispk daraz.pk
+  whoispk --all chaiwala
+  whoispk --json daraz google.com.pk
 
 Exit codes:
   0  all lookups completed
@@ -36,6 +43,9 @@ try {
   args = parseArgs({
     allowPositionals: true,
     options: {
+      all: { type: 'boolean', short: 'a' },
+      short: { type: 'boolean', short: 's' },
+      'no-short': { type: 'boolean' },
       json: { type: 'boolean', short: 'j' },
       timeout: { type: 'string', short: 't' },
       concurrency: { type: 'string', short: 'c' },
@@ -62,18 +72,30 @@ if (opts.version) {
 const timeout = parsePositiveInt(opts.timeout, 15_000, '--timeout');
 const concurrency = parsePositiveInt(opts.concurrency, 3, '--concurrency');
 
-let domains = positionals;
-if (!domains.length && !process.stdin.isTTY) {
-  domains = (await readStdin())
+let inputs = positionals;
+if (!inputs.length && !process.stdin.isTTY) {
+  inputs = (await readStdin())
     .split(/\r?\n/)
     .flatMap((line) => line.replace(/#.*/, '').split(/[\s,]+/))
     .filter(Boolean);
 }
-if (!domains.length) {
+if (!inputs.length) {
   process.stdout.write(HELP.trimStart());
   process.exit(2);
 }
 
+// Expand --all, normalise, and drop duplicates. Inputs that can't be normalised are kept
+// as typed, so their lookup reports the problem in place.
+const domains = [
+  ...new Set(
+    inputs
+      .flatMap((input) => (opts.all ? attempt(() => expandExtensions(input), [input]) : [input]))
+      .map((input) => attempt(() => normalizeDomain(input), input)),
+  ),
+];
+const short = opts['no-short'] ? false : Boolean(opts.short || opts.all);
+const nameWidth = Math.max(...domains.map((d) => d.length));
+
 // ---------------------------------------------------------------------------
 // Styling
 // ---------------------------------------------------------------------------
@@ -130,8 +152,14 @@ for (const [i, promise] of pending.entries()) {
   }
 
   spinner.clear();
-  if (i > 0) console.log('');
-  console.log(outcome.ok ? formatResult(outcome.result) : formatError(outcome.input, outcome.error));
+  if (short) {
+    // Blank line between groups of names, e.g. between "magic.*" and "chaiwala.*" with --all.
+    if (i > 0 && opts.all && baseName(domains[i]) !== baseName(domains[i - 1])) console.log('');
+    console.log(formatShort(outcome));
+  } else {
+    if (i > 0) console.log('');
+    console.log(outcome.ok ? formatResult(outcome.result) : formatError(outcome.input, outcome.error));
+  }
 }
 
 spinner.stop();
@@ -166,6 +194,22 @@ function formatResult(r) {
   return lines.join('\n');
 }
 
+function formatShort({ ok, input, result: r, error }) {
+  const name = c.bold((ok ? r.domain : input).padEnd(nameWidth));
+  const status = (text, colour) => colour(text.padEnd(18));
+  if (!ok) return `${name}  ${status('✖ Lookup failed', c.red)} ${c.dim(error.message)}`;
+  if (r.status === 'registered') {
+    const expiry = r.expireDate ? c.dim(`expires ${formatDate(r.expireDate)}`) : '';
+    return `${name}  ${status('● Registered', c.red)} ${expiry}`.trimEnd();
+  }
+  if (r.status === 'available') return `${name}  ${c.green('● Available')}`;
+  return `${name}  ${status('● Not registrable', c.yellow)} ${c.dim(r.reasons.join('; '))}`.trimEnd();
+}
+
+function baseName(domain) {
+  return domain.split('.')[0];
+}
+
 function formatError(domain, err) {
   return `${c.bold(domain)}  ${c.red('✖ Lookup failed')}\n  ${c.dim(err.message)}`;
 }
@@ -240,6 +284,14 @@ function createLimiter(max) {
     });
 }
 
+function attempt(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+
 function parsePositiveInt(raw, fallback, name) {
   if (raw === undefined) return fallback;
   const n = Number(raw);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whoispk",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Check .pk domain availability and registration details from PKNIC, from the command line or Node.js",
   "keywords": [
     "whois",

package/src/index.d.ts

@@ -52,10 +52,17 @@ export function lookup(domain: string, options?: LookupOptions): Promise<LookupR
 export function parse(html: string): Omit<LookupResult, 'domain'> & { domain: string | null };
 export function normalizeDomain(input: string): string;
 
+/** The .pk extensions anyone can register: pk, com.pk, net.pk, org.pk, biz.pk, web.pk, fam.pk. */
+export const EXTENSIONS: readonly string[];
+/** "magic" or "magic.com.pk" -> one domain per entry in EXTENSIONS. */
+export function expandExtensions(input: string): string[];
+
 declare const whoispk: {
   lookup: typeof lookup;
   parse: typeof parse;
   normalizeDomain: typeof normalizeDomain;
+  expandExtensions: typeof expandExtensions;
+  EXTENSIONS: readonly string[];
   WhoisPkError: typeof WhoisPkError;
   ENDPOINT: string;
 };

package/src/index.js

@@ -40,15 +40,47 @@ export function normalizeDomain(input) {
   return domain;
 }
 
+/**
+ * The .pk extensions anyone can register. PKNIC also has restricted ones
+ * (edu.pk, gov.pk, gok.pk, gob.pk, gop.pk, gos.pk) for institutions only.
+ */
+export const EXTENSIONS = Object.freeze(['pk', 'com.pk', 'net.pk', 'org.pk', 'biz.pk', 'web.pk', 'fam.pk']);
+
+const SECOND_LEVEL = /\.(?:com|net|org|biz|web|fam|edu|gov|gok|gob|gop|gos)$/;
+
+/**
+ * Expand a name into one domain per public .pk extension.
+ *
+ *   "magic" or "magic.com.pk" -> ["magic.pk", "magic.com.pk", "magic.net.pk", …]
+ *
+ * @param {string} input
+ * @returns {string[]}
+ */
+export function expandExtensions(input) {
+  const base = normalizeDomain(input).replace(/\.pk$/, '').replace(SECOND_LEVEL, '');
+  if (!base) {
+    throw new WhoisPkError(`"${input}" has no name to check`, { code: 'INVALID_INPUT' });
+  }
+  return EXTENSIONS.map((ext) => `${base}.${ext}`);
+}
+
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 async function request(domain, { endpoint, timeout, signal, fetch: fetchImpl }) {
-  const signals = [AbortSignal.timeout(timeout)];
-  if (signal) signals.push(signal);
+  // A regular (ref'd) timer rather than AbortSignal.timeout(): the latter doesn't keep the
+  // process alive, so a stalled request could let Node exit before the timeout ever fires.
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new DOMException(`Timed out after ${timeout} ms`, 'TimeoutError'));
+  }, timeout);
+  const forwardAbort = () => controller.abort(signal.reason);
+  if (signal?.aborted) forwardAbort();
+  else signal?.addEventListener('abort', forwardAbort, { once: true });
 
-  let response;
   try {
-    response = await fetchImpl(endpoint, {
+    const response = await fetchImpl(endpoint, {
       method: 'POST',
       headers: {
         'content-type': 'application/x-www-form-urlencoded',
@@ -56,29 +88,33 @@ async function request(domain, { endpoint, timeout, signal, fetch: fetchImpl })
         'user-agent': USER_AGENT,
       },
       body: new URLSearchParams({ name: domain }).toString(),
-      signal: AbortSignal.any(signals),
+      signal: controller.signal,
     });
+
+    if (!response.ok) {
+      throw new WhoisPkError(`PKNIC responded with HTTP ${response.status}`, {
+        code: 'HTTP_ERROR',
+        status: response.status,
+      });
+    }
+
+    return await response.text();
   } catch (err) {
+    if (err instanceof WhoisPkError) throw err;
+    if (timedOut) {
+      throw new WhoisPkError(`PKNIC did not respond within ${timeout} ms`, { code: 'TIMEOUT', cause: err });
+    }
     if (signal?.aborted) {
       throw new WhoisPkError('Lookup aborted', { code: 'ABORTED', cause: err });
     }
-    if (err?.name === 'TimeoutError') {
-      throw new WhoisPkError(`PKNIC did not respond within ${timeout} ms`, { code: 'TIMEOUT', cause: err });
-    }
     throw new WhoisPkError(`Could not reach PKNIC: ${err?.cause?.message ?? err?.message ?? err}`, {
       code: 'NETWORK_ERROR',
       cause: err,
     });
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener('abort', forwardAbort);
   }
-
-  if (!response.ok) {
-    throw new WhoisPkError(`PKNIC responded with HTTP ${response.status}`, {
-      code: 'HTTP_ERROR',
-      status: response.status,
-    });
-  }
-
-  return response.text();
 }
 
 /**
@@ -115,4 +151,4 @@ export async function lookup(input, options = {}) {
   }
 }
 
-export default { lookup, parse, normalizeDomain, WhoisPkError, ENDPOINT };
+export default { lookup, parse, normalizeDomain, expandExtensions, EXTENSIONS, WhoisPkError, ENDPOINT };