nukebase 2.0.4 → 2.0.6

package/bin/nukebase.js

@@ -8,6 +8,19 @@
 const args = require('../lib/args').parse(process.argv.slice(2));
 const { version } = require('../package.json');
 
+// "nukebase X is available": checked once a day while the command runs, printed
+// when the command finishes. 'exit' covers both kinds of command: project
+// commands end with process.exit, account commands end by themselves.
+// Not after --version, whose output scripts read.
+if (!(args.has('version') && !args.command)) {
+  const updates = require('../lib/update-check');
+  updates.scheduleCheck();
+  process.on('exit', () => {
+    const line = updates.notice(version);
+    if (line) console.error(line);
+  });
+}
+
 const ACCOUNT_COMMANDS = ['login', 'logout', 'accounts', 'use', 'whoami', 'create', 'link'];
 const PROJECT_COMMANDS = [
   'push', 'pull', 'update', 'rollback', 'restorepoints', 'restore-points', 'backup', 'env',

package/lib/project-commands.js

@@ -857,7 +857,9 @@ async function deleteProject() {
 // nukebase domain remove                   disconnect it
 //
 // The guided flow is the dashboard's modal in the terminal: it prints the two
-// A records to create, polls DNS until both point here (Enter to check now,
+// A records and the ownership TXT (nukebase.<domain> = nukebase-uid=<uid>,
+// which the server requires on a domain's first connection so no other
+// account can claim it) to create, polls DNS until they are in place (Enter to check now,
 // Ctrl+C to give up and come back later), then asks the server to verify and
 // issue the certificate — the slow part, up to a minute at Let's Encrypt.
 // --email is the cert contact; it defaults to the account email in
@@ -886,8 +888,9 @@ async function domainCommand() {
   if (sub) {
     if (args.has('wait')) {
       const ip = await regionIp();
-      printDnsRecords(ip);
-      await waitForDns(sub, ip);
+      const needTxt = (await currentDomain()) !== sub;   // already ours: proven when connected
+      printDnsRecords(ip, needTxt);
+      await waitForDns(sub, ip, needTxt);
     }
     await connectDomain(sub, email);
     process.exit(0);
@@ -916,8 +919,8 @@ async function domainCommand() {
     if (!/^[a-z0-9.-]+\.[a-z]{2,}$/.test(domain)) { console.log(`   "${domain}" does not look like a domain.`); domain = ''; }
   }
 
-  printDnsRecords(ip);
-  await waitForDns(domain, ip);
+  printDnsRecords(ip, true);
+  await waitForDns(domain, ip, true);
 
   // Step 3 — the server does the real verification and issues the cert.
   await connectDomain(domain, email);
@@ -962,12 +965,20 @@ async function regionIp() {
   return null;
 }
 
-function printDnsRecords(ip) {
+// The ownership record the server checks on a domain's first connection.
+const domainTxtValue = () => `nukebase-uid=${uid}`;
+
+function printDnsRecords(ip, withTxt) {
   console.log('\n   Step 1 — point it here. At your registrar (GoDaddy, Namecheap,');
   console.log('   Cloudflare, ...) add these DNS records:\n');
-  console.log('     Type   Name   Value');
-  console.log(`     A      @      ${ip || "(this region's IP — see the dashboard)"}`);
-  console.log(`     A      www    ${ip || '(same)'}`);
+  console.log('     Type   Name       Value');
+  console.log(`     A      @          ${ip || "(this region's IP — see the dashboard)"}`);
+  console.log(`     A      www        ${ip || '(same)'}`);
+  if (withTxt) {
+    console.log(`     TXT    nukebase   ${domainTxtValue()}`);
+    console.log('\n   The TXT record proves the domain is yours, so no other account can');
+    console.log('   connect it. One on your main domain covers its subdomains too.');
+  }
   console.log('\n   If you use Cloudflare, set the records to "DNS only" (grey cloud)');
   console.log('   so the certificate can be issued.\n');
 }
@@ -981,7 +992,7 @@ function printDnsRecords(ip) {
 // long after the server sees it — and on some Windows setups Node's own
 // resolver cannot reach the system DNS server at all (ECONNREFUSED on every
 // name). getaddrinfo is the fallback for a machine that blocks 1.1.1.1.
-async function waitForDns(domain, ip) {
+async function waitForDns(domain, ip, needTxt) {
   console.log('   Step 2 — waiting for DNS. This can take a few minutes.');
   console.log('   Press Enter to check now, Ctrl+C to stop and come back later.\n');
   const dns = require('dns').promises;
@@ -990,19 +1001,31 @@ async function waitForDns(domain, ip) {
     try { return await pub.resolve4(name); } catch (e) {}
     try { return (await dns.lookup(name, { all: true, family: 4 })).map(a => a.address); } catch (e) { return []; }
   };
-  let apexOk = false, wwwOk = false;
+  // Same rule as the server: nukebase.<domain>, then each parent.
+  const want = domainTxtValue().toLowerCase();
+  const txtFound = async () => {
+    const labels = domain.split('.');
+    for (let i = 0; i <= labels.length - 2; i++) {
+      let recs;
+      try { recs = await pub.resolveTxt('nukebase.' + labels.slice(i).join('.')); } catch (e) { continue; }
+      if (recs.some(chunks => chunks.join('').trim().toLowerCase() === want)) return true;
+    }
+    return false;
+  };
+  let apexOk = false, wwwOk = false, txtOk = !needTxt;
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   let poke = null;
   rl.on('line', () => { if (poke) poke(); });
   const wait = (ms) => new Promise(res => { poke = res; setTimeout(res, ms); });
   try {
     for (;;) {
-      const [apex, www] = await Promise.all([lookup(domain), lookup(`www.${domain}`)]);
+      const [apex, www, txt] = await Promise.all([lookup(domain), lookup(`www.${domain}`), needTxt ? txtFound() : true]);
       apexOk = ip ? apex.includes(ip) : apex.length > 0;
       wwwOk = ip ? www.includes(ip) : www.length > 0;
+      txtOk = txt;
       const mark = ok => ok ? '✓' : '…';
-      process.stdout.write(`\r   ${mark(apexOk)} ${domain} ${apex.length ? '→ ' + apex.join(', ') : '(no record yet)'}   ${mark(wwwOk)} www ${www.length ? '→ ' + www.join(', ') : '(no record yet)'}      `);
-      if (apexOk) break;
+      process.stdout.write(`\r   ${mark(apexOk)} ${domain} ${apex.length ? '→ ' + apex.join(', ') : '(no record yet)'}   ${mark(wwwOk)} www ${www.length ? '→ ' + www.join(', ') : '(no record yet)'}${needTxt ? `   ${mark(txtOk)} TXT ${txtOk ? 'found' : '(not yet)'}` : ''}      `);
+      if (apexOk && txtOk) break;
       await wait(15000);
     }
   } finally {

package/lib/update-check.js

@@ -0,0 +1,73 @@
+// "A newer nukebase is available" notice.
+//
+// A global install never updates itself, and while one is installed even
+// `npx nukebase` keeps running it. So once a day, while a command runs, the
+// CLI asks the npm registry for the latest version (one small request, 1.5 s
+// at most) and saves it next to the credentials. When the command finishes it
+// prints one line if that version is newer than the one running.
+//
+// Off when NUKEBASE_NO_UPDATE_CHECK or CI is set.
+
+const fs = require('fs');
+const path = require('path');
+const { FILE: CREDENTIALS_FILE } = require('./credentials');
+
+const CACHE = path.join(path.dirname(CREDENTIALS_FILE), 'update-check.json');
+const CHECK_EVERY_MS = 24 * 60 * 60 * 1000;
+const REGISTRY_URL = 'https://registry.npmjs.org/nukebase/latest';
+
+const disabled = () => !!(process.env.NUKEBASE_NO_UPDATE_CHECK || process.env.CI);
+
+function readCache() {
+  try { return JSON.parse(fs.readFileSync(CACHE, 'utf8')); } catch { return {}; }
+}
+
+// "2.0.10" > "2.0.9"; pre-release tags are ignored.
+function isNewer(a, b) {
+  const pa = String(a).split('-')[0].split('.').map(Number);
+  const pb = String(b).split('-')[0].split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) > (pb[i] || 0);
+  }
+  return false;
+}
+
+// Ask the registry, if a day has passed since the last time. Runs alongside
+// the command; a command that exits first simply checks again next time.
+// Never throws.
+function scheduleCheck() {
+  if (disabled()) return;
+  if (Date.now() - (readCache().checkedAt || 0) < CHECK_EVERY_MS) return;
+  runCheck().catch(() => {});
+}
+
+// The notice for the version running now, or null.
+function notice(current) {
+  if (disabled()) return null;
+  const { latest } = readCache();
+  if (!latest || !isNewer(latest, current)) return null;
+  // Run through npx (from npm's cache), or installed globally?
+  const viaNpx = __dirname.split(path.sep).includes('_npx');
+  const how = viaNpx
+    ? 'Run it with: npx nukebase@latest <command>'
+    : 'Update with: npm i -g nukebase@latest';
+  return `\nnukebase ${latest} is available (you have ${current}). ${how}`;
+}
+
+// One request to the registry; the answer is saved for a day.
+async function runCheck() {
+  let latest = null;
+  try {
+    const r = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(1500) });
+    if (r.ok) latest = (await r.json()).version || null;
+  } catch {}
+  try {
+    fs.mkdirSync(path.dirname(CACHE), { recursive: true });
+    // Record the attempt even when it failed, so an offline machine doesn't
+    // re-check on every command; keep the last known version.
+    const prev = readCache();
+    fs.writeFileSync(CACHE, JSON.stringify({ checkedAt: Date.now(), latest: latest || prev.latest || null }) + '\n');
+  } catch {}
+}
+
+module.exports = { scheduleCheck, notice, isNewer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nukebase",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "NukeBase CLI: create, deploy and manage NukeBase projects",
   "bin": {
     "nukebase": "bin/nukebase.js"
@@ -17,6 +17,13 @@
     "ws": "^8.20.0"
   },
   "homepage": "https://nukebase.com",
-  "keywords": ["nukebase", "database", "realtime", "hosting", "cli", "deploy"],
+  "keywords": [
+    "nukebase",
+    "database",
+    "realtime",
+    "hosting",
+    "cli",
+    "deploy"
+  ],
   "license": "MIT"
 }