namecrawl 1.0.0

package/bin/cli.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+import { startInteractive } from '../src/interactive.js';
+await startInteractive();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "namecrawl",
+  "version": "1.0.0",
+  "description": "CLI tool for searching domain availability, tracking trending domains, and managing your nameCrawl account",
+  "type": "module",
+  "bin": {
+    "namecrawl": "bin/cli.js"
+  },
+  "keywords": [
+    "domain",
+    "availability",
+    "whois",
+    "dns",
+    "cli",
+    "namecrawl"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "figlet": "^1.11.0",
+    "inquirer": "^9.3.7",
+    "ora": "^8.1.1"
+  },
+  "license": "MIT"
+}

package/src/commands/bulk.js

@@ -0,0 +1,101 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import chalk from 'chalk';
+import { post } from '../lib/api.js';
+import { spinner, blank, handleError, formatNumber } from '../lib/output.js';
+import { sanitize } from '../lib/sanitize.js';
+
+export function registerBulkCommand(program) {
+  program
+    .command('bulk [domains...]')
+    .description('Bulk check domain availability (Starter+ tier)')
+    .option('--tlds <tlds>', 'Comma-separated TLDs (e.g. com,io)', 'com')
+    .option('--file <path>', 'Read domains from a file (one per line)')
+    .option('--json', 'Output raw JSON')
+    .action(async (domains, opts) => {
+      try {
+        let domainList = domains || [];
+
+        if (opts.file) {
+          const filePath = resolve(opts.file);
+          const cwd = resolve(process.cwd());
+          if (!filePath.startsWith(cwd)) {
+            console.error('  File must be within the current working directory');
+            process.exitCode = 1;
+            return;
+          }
+          const content = await readFile(filePath, 'utf-8');
+          const fileDomains = content.split('\n').map(l => l.trim()).filter(Boolean);
+          domainList = [...domainList, ...fileDomains];
+        }
+
+        if (domainList.length === 0) {
+          console.error('  Provide domains as arguments or use |file');
+          process.exitCode = 1;
+          return;
+        }
+
+        const tlds = opts.tlds.split(',')
+          .map(t => t.trim().replace(/^\./, ''))
+          .filter(t => /^[a-zA-Z0-9]{2,20}$/.test(t))
+          .map(t => `.${t}`);
+
+        if (tlds.length === 0) {
+          console.error('  No valid TLDs provided');
+          process.exitCode = 1;
+          return;
+        }
+
+        const spin = spinner(`Checking ${domainList.length} domains across ${tlds.length} TLDs...`);
+        spin.start();
+
+        const data = await post('/v1/check/bulk', {
+          body: { domains: domainList, tlds, include_pricing: true },
+          auth: 'apikey',
+        });
+
+        spin.stop();
+
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        const results = data?.data?.results || {};
+        let totalAvailable = 0;
+        let totalTaken = 0;
+
+        blank();
+
+        for (const [domain, tldResults] of Object.entries(results)) {
+          console.log(`  ${chalk.bold(sanitize(domain))}`);
+
+          for (const r of tldResults) {
+            const fqdn = sanitize(r.fqdn || `${domain}${r.tld}`);
+            if (r.available) {
+              totalAvailable++;
+              const price = r.pricing?.[0]
+                ? chalk.yellow(`$${r.pricing[0].registration_price}/yr`)
+                : '';
+              console.log(`    ${chalk.green('\u2022')} ${fqdn.padEnd(25)} ${chalk.green('available')}  ${price}`);
+            } else {
+              totalTaken++;
+              console.log(`    ${chalk.red('\u2022')} ${chalk.dim(fqdn.padEnd(25))} ${chalk.dim('taken')}`);
+            }
+          }
+          blank();
+        }
+
+        const total = totalAvailable + totalTaken;
+        console.log(chalk.dim(`  ${totalAvailable} available - ${totalTaken} taken - ${total} checked`));
+
+        if (data?.meta?.queries_remaining != null) {
+          console.log(chalk.dim(`  ${formatNumber(data.meta.queries_remaining)} queries remaining`));
+        }
+
+        blank();
+      } catch (err) {
+        handleError(err);
+      }
+    });
+}

package/src/commands/crawler.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { get } from '../lib/api.js';
+import { spinner, blank, label, handleError, formatNumber } from '../lib/output.js';
+import { sanitize } from '../lib/sanitize.js';
+
+export function registerCrawlerCommand(program) {
+  program
+    .command('crawler')
+    .description('Show domain crawler statistics')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+      const spin = spinner('Fetching crawler stats...');
+      spin.start();
+
+      try {
+        const data = await get('/v1/public/crawler/stats');
+        spin.stop();
+
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        const d = data?.data || {};
+
+        blank();
+        console.log(`  ${chalk.bold('Domain Crawler')}`);
+        blank();
+        label('Indexed:   ', `${formatNumber(d.total_domains_indexed)} domains`);
+        label('Validated: ', `${formatNumber(d.domains_with_expiry || d.domains_registered)} (with RDAP data)`);
+        label('TLDs:      ', String(d.tlds_covered || 0));
+        label('Expiring:  ', `${formatNumber(d.expiring_within_30d)} (within 30 days)`);
+        blank();
+
+        if (d.top_tlds && d.top_tlds.length > 0) {
+          const topStr = d.top_tlds
+            .slice(0, 5)
+            .map(t => `${sanitize(t.tld)} (${formatNumber(t.count)})`)
+            .join(' - ');
+          label('Top TLDs:  ', topStr);
+          blank();
+        }
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+}

package/src/commands/keys.js

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+import { get, post, del } from '../lib/api.js';
+import { spinner, success, blank, handleError } from '../lib/output.js';
+import { sanitize } from '../lib/sanitize.js';
+
+export function registerKeysCommand(program) {
+  const keys = program
+    .command('keys')
+    .description('Manage API keys');
+
+  keys
+    .command('list')
+    .description('List your API keys')
+    .action(async () => {
+      const spin = spinner('Fetching keys...');
+      spin.start();
+
+      try {
+        const data = await get('/dashboard/keys', { auth: 'jwt' });
+        spin.stop();
+
+        const keyList = data?.data || [];
+        blank();
+
+        if (keyList.length === 0) {
+          console.log('  No API keys found.');
+        } else {
+          console.log(`  ${chalk.bold('API Keys')}`);
+          blank();
+          for (const k of keyList) {
+            const status = k.revoked_at ? chalk.red('revoked') : chalk.green('active');
+            const name = sanitize(k.name || 'unnamed');
+            const lastUsed = k.last_used_at
+              ? `last used ${new Date(k.last_used_at).toLocaleDateString()}`
+              : 'never used';
+            console.log(`  ${chalk.dim(k.key_prefix + '...')}  ${name}  ${status}  ${chalk.dim(lastUsed)}`);
+            console.log(chalk.dim(`  ID: ${k.id}`));
+            blank();
+          }
+        }
+
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+
+  keys
+    .command('create')
+    .description('Create a new API key')
+    .option('--name <name>', 'Key name', 'cli')
+    .action(async (opts) => {
+      const spin = spinner('Creating key...');
+      spin.start();
+
+      try {
+        const data = await post('/dashboard/keys', {
+          body: { name: opts.name, environment: 'live' },
+          auth: 'jwt',
+        });
+
+        spin.stop();
+        blank();
+        success('API key created:');
+        console.log(`  ${chalk.bold(data?.data?.key)}`);
+        console.log(chalk.dim('  Save this key - it won\'t be shown again.'));
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+
+  keys
+    .command('delete <id>')
+    .description('Delete an API key')
+    .action(async (id) => {
+      if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+        console.error('  Invalid key ID');
+        process.exitCode = 1;
+        return;
+      }
+
+      const spin = spinner('Deleting key...');
+      spin.start();
+
+      try {
+        await del(`/dashboard/keys/${id}`, { auth: 'jwt' });
+        spin.stop();
+        blank();
+        success('API key revoked');
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+}

package/src/commands/login.js

@@ -0,0 +1,226 @@
+import { exec } from 'node:child_process';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { get, post } from '../lib/api.js';
+import { saveConfig, clearConfig } from '../lib/config.js';
+import { spinner, success, error, info, blank, handleError } from '../lib/output.js';
+
+const SITE_URL = 'https://namecrawl.dev';
+
+function openBrowser(url) {
+  const cmd = process.platform === 'win32' ? `start "" "${url}"`
+    : process.platform === 'darwin' ? `open "${url}"`
+    : `xdg-open "${url}"`;
+  exec(cmd, () => {});
+}
+
+async function loginWithCredentials() {
+  let spin;
+  try {
+    const { email, password } = await inquirer.prompt([
+      { type: 'input', name: 'email', message: 'Email:' },
+      { type: 'password', name: 'password', message: 'Password:', mask: '\u2022' },
+    ]);
+
+    spin = spinner('Logging in...');
+    spin.start();
+
+    const res = await post('/auth/login', {
+      body: { email, password },
+    });
+
+    const apiKey = res?.data?.api_key;
+    const tier = res?.data?.tier || 'free';
+
+    await saveConfig({ api_key: apiKey, email: res?.data?.email || email, tier });
+
+    spin.stop();
+    blank();
+    success(`Logged in as ${email} (${tier} tier)`);
+    blank();
+  } catch (err) {
+    if (spin) spin.stop();
+    handleError(err);
+  }
+}
+
+async function signupWithCredentials() {
+  let spin;
+  try {
+    const { email, password, confirmPassword } = await inquirer.prompt([
+      { type: 'input', name: 'email', message: 'Email:' },
+      { type: 'password', name: 'password', message: 'Password (min 10 chars):', mask: '\u2022' },
+      { type: 'password', name: 'confirmPassword', message: 'Confirm password:', mask: '\u2022' },
+    ]);
+
+    if (password !== confirmPassword) {
+      error('Passwords do not match');
+      return;
+    }
+
+    if (password.length < 10) {
+      error('Password must be at least 10 characters');
+      return;
+    }
+
+    spin = spinner('Creating account...');
+    spin.start();
+
+    const res = await post('/auth/signup', {
+      body: { email, password },
+    });
+
+    const apiKey = res?.data?.api_key;
+    const tier = res?.data?.tier || 'free';
+
+    await saveConfig({ api_key: apiKey, email: res?.data?.email || email, tier });
+
+    spin.stop();
+    blank();
+    success(`Account created! Logged in as ${email} (${tier} tier)`);
+    blank();
+  } catch (err) {
+    if (spin) spin.stop();
+    handleError(err);
+  }
+}
+
+async function loginWithBrowser() {
+  let spin;
+  try {
+    // Request a device code from the API
+    spin = spinner('Requesting login session...');
+    spin.start();
+
+    const deviceRes = await post('/auth/device', {});
+    const deviceCode = deviceRes?.data?.device_code;
+    const userCode = deviceRes?.data?.user_code;
+    const verifyUrl = deviceRes?.data?.verification_url || `${SITE_URL}/cli-auth`;
+    const interval = (deviceRes?.data?.interval || 5) * 1000;
+
+    spin.stop();
+
+    // Build the auth URL
+    const authUrl = `${verifyUrl}?code=${userCode}`;
+
+    // Open browser
+    openBrowser(authUrl);
+
+    blank();
+    info('Opening browser to log in...');
+    blank();
+    console.log(chalk.dim('  If the browser did not open, visit:'));
+    console.log(`  ${chalk.hex('#00bcd4').underline(authUrl)}`);
+    blank();
+
+    // Poll until the user completes auth on the website
+    spin = spinner('Waiting for browser authentication...');
+    spin.start();
+
+    const maxAttempts = 120; // ~10 min at 5s intervals
+    for (let i = 0; i < maxAttempts; i++) {
+      await new Promise(r => setTimeout(r, interval));
+
+      try {
+        const pollRes = await get(`/auth/device/${deviceCode}`, {});
+        const status = pollRes?.data?.status;
+
+        if (status === 'complete') {
+          const apiKey = pollRes.data.api_key;
+          const email = pollRes.data.email;
+          const tier = pollRes.data.tier || 'free';
+
+          await saveConfig({ api_key: apiKey, email, tier });
+
+          spin.stop();
+          blank();
+          success(`Logged in as ${email} (${tier} tier)`);
+          blank();
+          return;
+        }
+
+        if (status === 'expired') {
+          spin.stop();
+          blank();
+          error('Login session expired. Please try again.');
+          blank();
+          return;
+        }
+
+        // status === 'pending' — keep polling
+      } catch {
+        // Not ready yet or network blip, keep polling
+      }
+    }
+
+    spin.stop();
+    blank();
+    error('Timed out waiting for authentication. Please try again.');
+    blank();
+  } catch (err) {
+    if (spin) spin.stop();
+    handleError(err);
+  }
+}
+
+export function registerLoginCommand(program) {
+  program
+    .command('login')
+    .description('Log in to your nameCrawl account')
+    .action(async () => {
+      const { method } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'method',
+          message: 'How would you like to log in?',
+          choices: [
+            { name: 'Log in with browser (Google, GitHub, etc.)', value: 'browser' },
+            { name: 'Log in with email & password', value: 'credentials' },
+          ],
+        },
+      ]);
+
+      if (method === 'browser') {
+        await loginWithBrowser();
+      } else {
+        await loginWithCredentials();
+      }
+    });
+
+  program
+    .command('signup')
+    .description('Create a new nameCrawl account')
+    .action(async () => {
+      const { method } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'method',
+          message: 'How would you like to sign up?',
+          choices: [
+            { name: 'Sign up with browser (Google, GitHub, etc.)', value: 'browser' },
+            { name: 'Sign up with email & password', value: 'credentials' },
+          ],
+        },
+      ]);
+
+      if (method === 'browser') {
+        await loginWithBrowser();
+      } else {
+        await signupWithCredentials();
+      }
+    });
+
+  program
+    .command('logout')
+    .description('Log out and clear stored credentials')
+    .action(async () => {
+      try {
+        await clearConfig();
+        blank();
+        success('Logged out');
+        blank();
+      } catch (err) {
+        handleError(err);
+      }
+    });
+}

package/src/commands/search.js

@@ -0,0 +1,116 @@
+import chalk from 'chalk';
+import { get, post } from '../lib/api.js';
+import { getApiKey } from '../lib/config.js';
+import { spinner, blank, handleError, formatNumber } from '../lib/output.js';
+import { sanitize } from '../lib/sanitize.js';
+
+// OSC 8 terminal hyperlink — clickable in most modern terminals, plain text fallback otherwise
+function termLink(text, url) {
+  return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+
+const cyan = chalk.hex('#00bcd4');
+const green = chalk.hex('#00ff88');
+const red = chalk.hex('#ff3366');
+const yellow = chalk.hex('#fbbf24');
+const dim = chalk.dim;
+const white = chalk.white;
+
+export function registerSearchCommand(program) {
+  program
+    .command('search <domain>')
+    .description('Search domain availability across TLDs')
+    .option('--tlds <tlds>', 'Comma-separated TLDs to check (e.g. com,io,dev)')
+    .option('--json', 'Output raw JSON')
+    .action(async (domain, opts) => {
+      const spin = spinner(`Searching: ${domain}`);
+      spin.start();
+
+      try {
+        const apiKey = await getApiKey();
+        let data;
+
+        if (apiKey && opts.tlds) {
+          const tlds = opts.tlds.split(',').map(t => t.startsWith('.') ? t : `.${t}`);
+          data = await post('/v1/check', {
+            body: { domain, tlds, include_pricing: true },
+            auth: 'apikey',
+          });
+        } else if (apiKey) {
+          data = await post('/v1/check', {
+            body: { domain, include_pricing: true },
+            auth: 'apikey',
+          });
+        } else {
+          data = await post('/v1/public/check', {
+            body: { domain },
+          });
+        }
+
+        spin.stop();
+
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        blank();
+        console.log(`  ${cyan.bold(sanitize(domain))}`);
+        blank();
+
+        const results = data?.data?.results || [];
+        let available = 0;
+        let taken = 0;
+
+        for (const r of results) {
+          const fqdn = sanitize(r.fqdn || `${domain}${r.tld}`);
+
+          if (r.available) {
+            available++;
+            console.log(`  ${green('\u2022')} ${white.bold(fqdn)} ${green('available')}`);
+
+            // Show all pricing rows with clickable registrar links
+            const prices = r.pricing || [];
+            const links = r.registration_links || [];
+            if (prices.length > 0) {
+              // Sort cheapest first
+              const sorted = [...prices].sort((a, b) => a.registration_price - b.registration_price);
+              for (let i = 0; i < sorted.length; i++) {
+                const p = sorted[i];
+                const regName = sanitize(p.registrar || 'unknown');
+                const link = links.find(l => l.registrar === p.registrar);
+                const regLabel = link?.url
+                  ? dim(termLink(regName.padEnd(16), link.url))
+                  : dim(regName.padEnd(16));
+                const regPrice = yellow(`$${p.registration_price}/yr`);
+                const renewPrice = dim(`renew $${p.renewal_price}/yr`);
+                const cheapest = i === 0 ? green(' <- best') : '';
+                console.log(`      ${regPrice}  ${regLabel} ${renewPrice}${cheapest}`);
+              }
+            }
+            blank();
+          } else {
+            taken++;
+            const extra = formatTakenExtra(r);
+            console.log(`  ${red('\u2022')} ${dim(fqdn)} ${dim('taken')}${extra ? '  ' + dim(extra) : ''}`);
+          }
+        }
+
+        blank();
+        console.log(dim(`  ${available} available - ${taken} taken - ${results.length} checked`));
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+}
+
+function formatTakenExtra(r) {
+  if (r.expiry_date) {
+    const exp = new Date(r.expiry_date);
+    return `expires ${exp.toISOString().split('T')[0]}`;
+  }
+  if (r.registrar) return sanitize(r.registrar);
+  return '';
+}

package/src/commands/status.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { get } from '../lib/api.js';
+import { loadConfig } from '../lib/config.js';
+import { spinner, blank, label, handleError, formatNumber } from '../lib/output.js';
+
+export function registerStatusCommand(program) {
+  program
+    .command('status')
+    .description('Show account status and quota usage')
+    .action(async () => {
+      const spin = spinner('Fetching account status...');
+      spin.start();
+
+      try {
+        const config = await loadConfig();
+        const data = await get('/dashboard/overview', { auth: 'jwt' });
+
+        spin.stop();
+
+        const user = data?.data?.user || {};
+        const usage = data?.data?.usage || {};
+        const sub = data?.data?.subscription || {};
+
+        const tier = sub.tier || config.tier || 'free';
+        const limits = getTierLimits(tier);
+
+        blank();
+        label('Account:', user.email || config.email || 'unknown');
+        label('Tier:   ', capitalize(tier));
+        label('Quota:  ',
+          `${formatNumber(usage.queries_today)} / ${formatNumber(limits.daily)} daily - ` +
+          `${formatNumber(usage.queries_this_month)} / ${formatNumber(limits.monthly)} monthly`
+        );
+        label('Rate:   ', `${limits.rate} req/min`);
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+}
+
+function getTierLimits(tier) {
+  const tiers = {
+    free:    { daily: 100, monthly: 3000, rate: 10 },
+    starter: { daily: null, monthly: 10000, rate: 60 },
+    pro:     { daily: null, monthly: 100000, rate: 120 },
+  };
+  return tiers[tier] || tiers.free;
+}
+
+function capitalize(s) {
+  return s ? s.charAt(0).toUpperCase() + s.slice(1) : '';
+}

package/src/commands/trending.js

@@ -0,0 +1,94 @@
+import chalk from 'chalk';
+import { get } from '../lib/api.js';
+import { spinner, blank, handleError } from '../lib/output.js';
+import { sanitize } from '../lib/sanitize.js';
+
+const CATEGORIES = ['most_searched', 'newly_available', 'expiring_soon', 'rising'];
+const PERIODS = ['1h', '24h', '7d', '30d'];
+
+export function registerTrendingCommand(program) {
+  program
+    .command('trending')
+    .description('View trending domains')
+    .option('--category <category>', `Category: ${CATEGORIES.join(', ')}`, 'most_searched')
+    .option('--period <period>', `Time period: ${PERIODS.join(', ')}`, '24h')
+    .option('--limit <n>', 'Number of results', '20')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+      if (!CATEGORIES.includes(opts.category)) {
+        console.error(`  Invalid category. Use: ${CATEGORIES.join(', ')}`);
+        process.exitCode = 1;
+        return;
+      }
+      if (!PERIODS.includes(opts.period)) {
+        console.error(`  Invalid period. Use: ${PERIODS.join(', ')}`);
+        process.exitCode = 1;
+        return;
+      }
+      const limit = parseInt(opts.limit, 10);
+      if (isNaN(limit) || limit < 1 || limit > 1000) {
+        console.error('  Limit must be a number between 1 and 1000');
+        process.exitCode = 1;
+        return;
+      }
+
+      const spin = spinner('Fetching trends...');
+      spin.start();
+
+      try {
+        const data = await get('/v1/public/trending', {
+          query: {
+            category: opts.category,
+            period: opts.period,
+            limit: String(limit),
+          },
+        });
+
+        spin.stop();
+
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        const categoryLabel = opts.category.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+
+        blank();
+        console.log(`  ${chalk.bold('Trending:')} ${categoryLabel} (${opts.period})`);
+        blank();
+
+        const trends = data?.data?.trends || [];
+
+        if (trends.length === 0) {
+          console.log('  No trending domains found.');
+        } else {
+          // Header
+          console.log(`  ${chalk.dim('#'.padStart(3))}   ${chalk.dim('Domain'.padEnd(30))} ${chalk.dim('TLD'.padEnd(8))} ${chalk.dim('Info')}`);
+
+          for (let i = 0; i < trends.length; i++) {
+            const t = trends[i];
+            const rank = String(i + 1).padStart(3);
+            const domain = sanitize(t.domain || t.fqdn || '').padEnd(30);
+            const tld = sanitize(t.tld || '').padEnd(8);
+            const info = sanitize(formatTrendInfo(t, opts.category));
+            console.log(`  ${rank}   ${domain} ${tld} ${chalk.dim(info)}`);
+          }
+        }
+
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+}
+
+function formatTrendInfo(t, category) {
+  if (category === 'expiring_soon' && t.expiry_date) {
+    const days = Math.ceil((new Date(t.expiry_date) - Date.now()) / (1000 * 60 * 60 * 24));
+    return days > 0 ? `${days} days` : 'expired';
+  }
+  if (t.search_count) return `${t.search_count} searches`;
+  if (t.status) return t.status;
+  return '';
+}

package/src/commands/update.js

@@ -0,0 +1,55 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import chalk from 'chalk';
+import { spinner, blank, success, error, info } from '../lib/output.js';
+
+const execFileAsync = promisify(execFile);
+
+export function registerUpdateCommand(program) {
+  program
+    .command('update')
+    .description('Update namecrawl to the latest version')
+    .action(async () => {
+      const currentVersion = program.version();
+      const spin = spinner('Checking for updates...');
+      spin.start();
+
+      let latestVersion;
+      try {
+        const { stdout } = await execFileAsync('npm', ['view', 'namecrawl', 'version']);
+        latestVersion = stdout.trim();
+      } catch (err) {
+        spin.stop();
+        error('Could not check for updates. Are you connected to the internet?');
+        if (process.env.DEBUG) info(err.message?.slice(0, 100));
+        process.exitCode = 1;
+        return;
+      }
+
+      if (currentVersion === latestVersion) {
+        spin.stop();
+        blank();
+        success(`Already on the latest version (${currentVersion})`);
+        blank();
+        return;
+      }
+
+      spin.text = `Updating ${chalk.dim(currentVersion)} ->${chalk.green(latestVersion)}...`;
+
+      try {
+        await execFileAsync('npm', ['install', '-g', 'namecrawl@latest']);
+        spin.stop();
+        blank();
+        success(`Updated to ${latestVersion}`);
+        blank();
+      } catch (err) {
+        spin.stop();
+        blank();
+        error('Update failed. Try running manually:');
+        info('npm install -g namecrawl@latest');
+        if (process.env.DEBUG) info(err.message?.slice(0, 100));
+        blank();
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/watch.js

@@ -0,0 +1,95 @@
+import chalk from 'chalk';
+import { get, post, del } from '../lib/api.js';
+import { spinner, success, blank, handleError } from '../lib/output.js';
+import { sanitize } from '../lib/sanitize.js';
+
+export function registerWatchCommand(program) {
+  const watch = program
+    .command('watch [domain]')
+    .description('Watch a domain for status changes (Pro tier)')
+    .action(async (domain, opts, cmd) => {
+      // If no domain and no subcommand, show help
+      if (!domain) {
+        cmd.help();
+        return;
+      }
+
+      const spin = spinner(`Watching ${domain}...`);
+      spin.start();
+
+      try {
+        const data = await post('/v1/watch', {
+          body: { domain },
+          auth: 'apikey',
+        });
+
+        spin.stop();
+        blank();
+        success(`Now watching ${sanitize(domain)}`);
+        if (data?.data?.expiry_date) {
+          const exp = new Date(data.data.expiry_date).toISOString().split('T')[0];
+          console.log(chalk.dim(`  Expires: ${exp}`));
+        }
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+
+  watch
+    .command('list')
+    .description('List watched domains')
+    .action(async () => {
+      const spin = spinner('Fetching watchlist...');
+      spin.start();
+
+      try {
+        const data = await get('/v1/watch/list', { auth: 'apikey' });
+        spin.stop();
+
+        const items = data?.data || [];
+        blank();
+
+        if (items.length === 0) {
+          console.log('  No watched domains.');
+        } else {
+          console.log(`  ${chalk.bold('Watched Domains')}`);
+          blank();
+          for (const w of items) {
+            const expiry = w.expiry_date
+              ? new Date(w.expiry_date).toISOString().split('T')[0]
+              : 'unknown';
+            const status = w.is_active ? chalk.green('active') : chalk.dim('paused');
+            console.log(`  ${sanitize(w.domain).padEnd(30)} ${status}  Expires: ${chalk.dim(expiry)}`);
+            console.log(chalk.dim(`  ID: ${w.id}`));
+            blank();
+          }
+        }
+
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+
+  watch
+    .command('remove <id>')
+    .description('Remove a domain from your watchlist')
+    .action(async (id) => {
+      const spin = spinner('Removing...');
+      spin.start();
+
+      try {
+        await del(`/v1/watch/${id}`, { auth: 'apikey' });
+        spin.stop();
+        blank();
+        success('Domain removed from watchlist');
+        blank();
+      } catch (err) {
+        spin.stop();
+        handleError(err);
+      }
+    });
+}

package/src/interactive.js

@@ -0,0 +1,216 @@
+import readline from 'node:readline';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { Command } from 'commander';
+import { loadConfig } from './lib/config.js';
+import { registerSearchCommand } from './commands/search.js';
+import { registerLoginCommand } from './commands/login.js';
+import { registerStatusCommand } from './commands/status.js';
+import { registerKeysCommand } from './commands/keys.js';
+import { registerTrendingCommand } from './commands/trending.js';
+import { registerWatchCommand } from './commands/watch.js';
+import { registerBulkCommand } from './commands/bulk.js';
+
+import { registerUpdateCommand } from './commands/update.js';
+
+const VERSION = '1.0.0';
+
+// Double Ctrl+C always exits, even during commands
+let lastSigint = 0;
+process.on('SIGINT', () => {
+  const now = Date.now();
+  if (now - lastSigint < 1500) {
+    console.log(chalk.dim('\n\n  Goodbye.\n'));
+    process.exit(0);
+  }
+  lastSigint = now;
+});
+
+const cyan = chalk.hex('#00bcd4');
+const cyanBold = chalk.hex('#00bcd4').bold;
+const green = chalk.hex('#00ff88');
+const pink = chalk.hex('#ff3366');
+const dim = chalk.dim;
+const white = chalk.white;
+const bold = chalk.bold;
+
+function printBanner() {
+  const title = figlet.textSync('nameCrawl', { font: 'ANSI Regular' });
+
+  console.log();
+  for (const line of title.split('\n')) {
+    if (line.trim()) console.log(`  ${cyanBold(line)}`);
+  }
+  console.log();
+  console.log(`  ${white.bold('nameCrawl')} ${dim('v' + VERSION)} ${dim('// domain intelligence cli')}`);
+  console.log();
+}
+
+async function printAuthStatus() {
+  const config = await loadConfig();
+  if (config.email) {
+    console.log(`  ${green('[*]')} ${white(config.email)} ${dim('/')} ${cyan(config.tier || 'free')}`);
+  } else {
+    console.log(`  ${dim('[*] not authenticated')} ${dim('--')} type ${white('login')} or ${white('signup')}`);
+  }
+}
+
+function printHelp() {
+  const P = 24;
+  const h = (c, desc) => `      ${cyan(c)}${' '.repeat(Math.max(1, P - c.length))}${dim(desc)}`;
+
+  console.log();
+  console.log(`  ${bold('  Search & Discovery')}`);
+  console.log();
+  console.log(h('search <domain>', 'Check domain availability'));
+  console.log(h('trending', 'View trending domains'));
+  console.log(h('bulk <domains...>', 'Bulk availability check'));
+  console.log(h('watch <domain>', 'Watch for status changes'));
+
+  console.log();
+  console.log(`  ${bold('  Account')}`);
+  console.log();
+  console.log(h('login', 'Log in to your account'));
+  console.log(h('signup', 'Create an account'));
+  console.log(h('logout', 'Log out'));
+  console.log(h('status', 'Account status & quota'));
+  console.log(h('keys', 'Manage API keys'));
+  console.log();
+  console.log(`  ${bold('  System')}`);
+  console.log();
+  console.log(h('update', 'Update nameCrawl'));
+  console.log(h('clear', 'Clear screen'));
+  console.log(h('exit', 'Exit'));
+  console.log();
+}
+
+function splitArgs(input) {
+  const args = [];
+  let current = '';
+  let inQuote = false;
+  let quoteChar = '';
+
+  for (const ch of input) {
+    if (inQuote) {
+      if (ch === quoteChar) inQuote = false;
+      else current += ch;
+    } else if (ch === '"' || ch === "'") {
+      inQuote = true;
+      quoteChar = ch;
+    } else if (ch === ' ' || ch === '\t') {
+      if (current) { args.push(current); current = ''; }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) args.push(current);
+  return args;
+}
+
+function createProgram() {
+  const prog = new Command();
+  prog.name('namecrawl');
+  prog.exitOverride();
+  prog.configureOutput({
+    writeOut: (str) => process.stdout.write(str),
+    writeErr: (str) => process.stderr.write(str),
+  });
+
+  registerSearchCommand(prog);
+  registerLoginCommand(prog);
+  registerStatusCommand(prog);
+  registerKeysCommand(prog);
+  registerTrendingCommand(prog);
+  registerWatchCommand(prog);
+  registerBulkCommand(prog);
+
+  registerUpdateCommand(prog);
+
+  return prog;
+}
+
+const commandHistory = [];
+
+function askLine(promptStr) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+      history: [...commandHistory],
+      historySize: 200,
+    });
+    rl.question(promptStr, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (trimmed && commandHistory[commandHistory.length - 1] !== trimmed) {
+        commandHistory.push(trimmed);
+      }
+      resolve(trimmed);
+    });
+    rl.on('SIGINT', () => {
+      rl.close();
+      resolve(null);
+    });
+  });
+}
+
+export async function startInteractive() {
+  console.clear();
+  printBanner();
+  await printAuthStatus();
+  console.log(dim(`  [>] type ${white('help')} for commands - ${white('exit')} to quit`));
+  console.log();
+
+  const promptStr = `  ${cyanBold('nameCrawl')} ${dim('>')} `;
+
+  while (true) {
+    const input = await askLine(promptStr);
+
+    if (input === null) {
+      console.log();
+      continue;
+    }
+
+    if (!input) continue;
+
+    const args = splitArgs(input);
+    const cmd = args[0].toLowerCase();
+
+    if (cmd === 'exit' || cmd === 'quit') {
+      console.log(dim('\n  Goodbye.\n'));
+      process.exit(0);
+    }
+
+    if (cmd === 'help') {
+      printHelp();
+      continue;
+    }
+
+    if (cmd === 'clear') {
+      console.clear();
+      printBanner();
+      continue;
+    }
+
+    try {
+      const prog = createProgram();
+      await prog.parseAsync(['node', 'namecrawl', ...args]);
+    } catch (err) {
+      if (err.code === 'commander.helpDisplayed' || err.code === 'commander.version') {
+        // Expected
+      } else if (err.code === 'commander.unknownCommand') {
+        console.log();
+        console.log(pink(`  Unknown command: ${cmd}`));
+        console.log(dim(`  type ${white('help')} for available commands`));
+        console.log();
+      } else if (err.code?.startsWith('commander.')) {
+        // Commander validation errors already displayed
+      } else {
+        console.log(pink(`  Error: ${err.message}`));
+      }
+    }
+
+    process.exitCode = 0;
+  }
+}

package/src/lib/api.js

@@ -0,0 +1,68 @@
+import { getApiKey, getJwt } from './config.js';
+
+const BASE_URL = 'https://api.namecrawl.dev';
+
+export class ApiError extends Error {
+  constructor(status, message, retryAfter = null) {
+    super(message);
+    this.name = 'ApiError';
+    this.status = status;
+    this.retryAfter = retryAfter;
+  }
+}
+
+async function request(method, path, { body, auth = 'none', query, token } = {}) {
+  const url = new URL(path, BASE_URL);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== undefined && v !== null) url.searchParams.set(k, v);
+    }
+  }
+
+  const headers = { 'Content-Type': 'application/json' };
+
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  } else if (auth === 'apikey') {
+    const key = await getApiKey();
+    if (!key) throw new ApiError(401, 'Not logged in. Run: namecrawl login');
+    headers['Authorization'] = `Bearer ${key}`;
+  } else if (auth === 'jwt') {
+    const jwt = await getJwt();
+    if (!jwt) throw new ApiError(401, 'Not logged in. Run: namecrawl login');
+    headers['Authorization'] = `Bearer ${jwt}`;
+  }
+
+  const opts = { method, headers };
+  if (body) opts.body = JSON.stringify(body);
+
+  const res = await fetch(url, opts);
+
+  if (res.status === 429) {
+    const retryAfter = res.headers.get('retry-after');
+    throw new ApiError(429, 'Rate limited', retryAfter ? parseInt(retryAfter, 10) : null);
+  }
+
+  const json = await res.json().catch(() => null);
+
+  if (!res.ok) {
+    const raw = json?.error?.message || json?.message || `Request failed (${res.status})`;
+    // Truncate and strip anything that looks like a token/key from error messages
+    const msg = raw.length > 200 ? raw.slice(0, 200) + '...' : raw;
+    throw new ApiError(res.status, msg.replace(/[A-Za-z0-9_\-]{40,}/g, '[REDACTED]'));
+  }
+
+  return json;
+}
+
+export function get(path, opts) {
+  return request('GET', path, opts);
+}
+
+export function post(path, opts) {
+  return request('POST', path, opts);
+}
+
+export function del(path, opts) {
+  return request('DELETE', path, opts);
+}

package/src/lib/config.js

@@ -0,0 +1,34 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+
+const CONFIG_DIR = join(homedir(), '.namecrawl');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+export async function loadConfig() {
+  try {
+    const data = await readFile(CONFIG_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+
+export async function saveConfig(config) {
+  await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+}
+
+export async function clearConfig() {
+  await saveConfig({});
+}
+
+export async function getApiKey() {
+  const config = await loadConfig();
+  return config.api_key || null;
+}
+
+export async function getJwt() {
+  const config = await loadConfig();
+  return config.jwt || null;
+}

package/src/lib/output.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+export function spinner(text) {
+  return ora({ text, color: 'cyan' });
+}
+
+export function success(msg) {
+  console.log(chalk.green('  ' + msg));
+}
+
+export function warn(msg) {
+  console.log(chalk.yellow('  ' + msg));
+}
+
+export function error(msg) {
+  console.error(chalk.red('  ' + msg));
+}
+
+export function info(msg) {
+  console.log(chalk.dim('  ' + msg));
+}
+
+export function label(key, value) {
+  console.log(`  ${chalk.dim(key)}  ${value}`);
+}
+
+export function blank() {
+  console.log();
+}
+
+export function handleError(err) {
+  if (err.name === 'ApiError') {
+    if (err.status === 429) {
+      const retry = err.retryAfter ? ` Retry in ${err.retryAfter}s.` : '';
+      warn(`Rate limited.${retry} Sign up for higher limits: namecrawl signup`);
+    } else {
+      error(err.message);
+    }
+  } else {
+    error(err.message || 'An unexpected error occurred');
+  }
+  process.exitCode = 1;
+}
+
+export function formatNumber(n) {
+  if (n == null) return '-';
+  return n.toLocaleString('en-US');
+}

package/src/lib/sanitize.js

@@ -0,0 +1,6 @@
+// Strip ANSI escape sequences to prevent terminal injection
+export function sanitize(str) {
+  if (typeof str !== 'string') return '';
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]|\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}