nukebase 2.5.0 → 2.5.2

package/lib/project-commands.js

@@ -177,34 +177,83 @@ function splitBySize(files, sizeOf, n) {
 }
 
 // One progress line shared by every stream of a transfer. counter() gives each
-// stream its own pass-through that adds to the shared total.
+// stream its own pass-through that adds to the shared total; add(n) counts
+// bytes moved without a stream (storage uploads; negative takes back a failed
+// attempt).
+//
+// The speed is the rate over the last few seconds, not the average since the
+// start, and it is redrawn on a timer rather than when bytes arrive:
+//  - An upload's bytes are counted as they enter the request. The first
+//    several MB land in Node's and the OS's send buffers almost at once
+//    (measured ~10 MB on Windows), so a whole-run average opened far above
+//    the line speed and took a long time to fall. The window starts only once
+//    the buffers have filled (SETTLE_MS after the first byte); from then on
+//    the counted bytes move at the real pace.
+//  - Redrawing only on data froze the line during a stall, then jumped.
+// Live redraws go to a terminal only (in a log or an AI agent they pile up);
+// the final line, with the whole-run average, is always printed.
 function progressMeter(totalBytes) {
-  let bytes = 0;
-  let last = 0;
+  const TICK_MS = 250;      // redraw interval
+  const SETTLE_MS = 1000;   // after the first byte: buffers filling, not measured
+  const WINDOW_MS = 5000;   // speed = bytes over (at most) this long
+  // Shortest span worth showing a speed for. Bytes leave in steps of a few MB
+  // (the OS frees send buffer in bursts), so a shorter span can catch a gap
+  // between steps and read 0.
+  const MIN_SPAN_MS = 2000;
+  const SMOOTH = 0.3;       // per-tick weight of the newest reading
+  const tty = !!process.stdout.isTTY;
   const start = Date.now();
+  let bytes = 0;
+  let firstAt = 0;
+  let speed = null;         // bytes per second, smoothed; null until measured
+  const samples = [];       // [time, bytes], from SETTLE_MS after the first byte
   const mb = (n) => (n / 1024 / 1024).toFixed(2);
-  const draw = (force) => {
+
+  const measure = () => {
     const now = Date.now();
-    if (!force && now - last < 100) return;
-    last = now;
-    const secs = (now - start) / 1000;
-    const speed = secs > 0 ? (bytes / 1024 / 1024) / secs : 0;
-    const remaining = Math.max(0, totalBytes - bytes);
-    const eta = speed > 0 ? formatEta((remaining / 1024 / 1024) / speed) : '--:--';
+    if (bytes > 0 && !firstAt) firstAt = now;
+    if (!firstAt || now - firstAt < SETTLE_MS) return;
+    // All of an upload counted: the tail is still in the send buffers, going
+    // out at the same pace. Hold the speed rather than let it decay to 0.
+    if (totalBytes > 0 && bytes >= totalBytes) return;
+    samples.push([now, bytes]);
+    while (samples.length > 2 && now - samples[1][0] >= WINDOW_MS) samples.shift();
+    const [t0, b0] = samples[0];
+    if (now - t0 < MIN_SPAN_MS) return;
+    const rate = Math.max(0, (bytes - b0) / ((now - t0) / 1000));
+    speed = speed === null ? rate : speed + SMOOTH * (rate - speed);
+  };
+  const line = () => {
+    const shown = totalBytes > 0 ? Math.min(bytes, totalBytes) : bytes;
     const of = totalBytes > 0 ? ` of ${mb(totalBytes).padStart(7)}` : '';
-    process.stdout.write(`\r   ${mb(bytes).padStart(7)}${of} MB || ${speed.toFixed(2).padStart(6)} MB/s || ETA ${String(eta).padStart(5)}    `);
+    const rate = speed === null ? '    -- MB/s' : `${(speed / 1024 / 1024).toFixed(2).padStart(6)} MB/s (${Math.round(speed * 8 / 1e6)} Mbps)`;
+    const remaining = Math.max(0, totalBytes - bytes);
+    const eta = totalBytes > 0 && remaining === 0 ? 'finishing'
+      : speed > 0 && totalBytes > 0 ? formatEta(remaining / speed) : '--:--';
+    return `\r   ${mb(shown).padStart(7)}${of} MB || ${rate} || ETA ${String(eta).padStart(5)}    `;
   };
+  const tick = () => { measure(); if (tty) process.stdout.write(line()); };
+  const timer = setInterval(tick, TICK_MS);
+  if (timer.unref) timer.unref();
+
   return {
     counter() {
-      return new Transform({ transform(chunk, enc, cb) { bytes += chunk.length; draw(false); cb(null, chunk); } });
+      return new Transform({ transform(chunk, enc, cb) { bytes += chunk.length; cb(null, chunk); } });
     },
-    // Bytes moved without a stream to count them (storage uploads).
-    add(n) { bytes += n; draw(false); },
+    add(n) { bytes = Math.max(0, bytes + n); },
     bytes: () => bytes,
+    // For a transfer that failed: stop redrawing and end the line, so the
+    // error printed next is not drawn over. done() is for one that finished.
+    stop() {
+      clearInterval(timer);
+      if (tty && firstAt) process.stdout.write('\n');
+    },
     done() {
-      draw(true);
+      clearInterval(timer);
+      if (tty) process.stdout.write(line());
       const secs = Math.max((Date.now() - start) / 1000, 0.001);
-      console.log(`\n   ✓ ${mb(bytes)} MB in ${secs.toFixed(1)}s (avg: ${(bytes / 1024 / 1024 / secs).toFixed(2)} MB/s)`);
+      const avg = bytes / secs;
+      console.log(`${tty ? '\n' : ''}   ✓ ${mb(bytes)} MB in ${secs.toFixed(1)}s (avg: ${(avg / 1024 / 1024).toFixed(2)} MB/s, ${Math.round(avg * 8 / 1e6)} Mbps)`);
     }
   };
 }
@@ -283,6 +332,9 @@ async function downloadStreams(dest, files, sizeOf, totalBytes) {
         if (!stopRequested) throw err;
       }
     }));
+  } catch (err) {
+    meter.stop();
+    throw err;
   } finally {
     process.off('SIGINT', onSigint);
   }
@@ -908,8 +960,9 @@ async function domainCommand() {
     if (args.has('wait')) {
       const ip = await regionIp();
       const needTxt = (await currentDomain()) !== sub;   // already ours: proven when connected
-      printDnsRecords(ip, needTxt);
-      await waitForDns(sub, ip, needTxt);
+      const kind = domainKind(sub);
+      printDnsRecords(ip, needTxt, kind);
+      await waitForDns(sub, ip, needTxt, kind);
     }
     await connectDomain(sub, email);
     if (args.has('email-domain')) await emailDomainCommand(null);
@@ -939,8 +992,9 @@ async function domainCommand() {
     if (!/^[a-z0-9.-]+\.[a-z]{2,}$/.test(domain)) { console.log(`   "${domain}" does not look like a domain.`); domain = ''; }
   }
 
-  printDnsRecords(ip, true);
-  await waitForDns(domain, ip, true);
+  const kind = domainKind(domain);
+  printDnsRecords(ip, true, kind);
+  await waitForDns(domain, ip, true, kind);
 
   // Step 3 — the server does the real verification and issues the cert.
   await connectDomain(domain, email);
@@ -1083,7 +1137,7 @@ async function connectDomain(domain, email) {
   });
   console.log(`\n✓ https://${r.domain} is live.`);
   if (r.wwwNote) console.log(`   ${r.wwwNote}`);
-  else if (r.verified) console.log('   www redirects to the apex if its A record also points here.');
+  else if (r.verified) console.log('   www redirects to the main domain.');
 }
 
 // This region's public IP, from /region-info. null when it cannot be read;
@@ -1099,31 +1153,47 @@ async function regionIp() {
 // The ownership record the server checks on a domain's first connection.
 const domainTxtValue = () => `nukebase-uid=${uid}`;
 
-function printDnsRecords(ip, withTxt) {
+// A domain of its own (example.com) or a subdomain (app.example.com), and
+// what its record is called (@, or "app"). By the dots: two labels is a
+// domain, three or more a subdomain, except under a two-part ending
+// (example.co.uk is a domain). Only for the instructions; the server decides
+// at connect. Same rule as the dashboard's domainKind.
+const TWO_PART_ENDING = /^(co|com|net|org|gov|edu|ac|ltd|plc|sch)\.[a-z]{2}$/;
+function domainKind(domain) {
+  const labels = domain.split('.');
+  const base = labels.length >= 3 && TWO_PART_ENDING.test(labels.slice(-2).join('.')) ? 3 : 2;
+  if (labels.length <= base) return { subdomain: false, zone: domain, name: '@' };
+  return { subdomain: true, zone: labels.slice(-base).join('.'), name: labels.slice(0, -base).join('.') };
+}
+
+function printDnsRecords(ip, withTxt, kind) {
+  const sub = kind && kind.subdomain;
+  const pad = (s) => s.padEnd(10);
   console.log('\n   Step 1 — point it here. At your registrar (GoDaddy, Namecheap,');
-  console.log('   Cloudflare, ...) add these DNS records:\n');
+  console.log(`   Cloudflare, ...) add these DNS records${sub ? ` to ${kind.zone}` : ''}:\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(`     A      ${pad(sub ? kind.name : '@')} ${ip || "(this region's IP — see the dashboard)"}`);
+  if (!sub) 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.');
   }
+  if (sub) console.log(`\n   ${kind.name}.${kind.zone} is a subdomain, so no www record is needed.`);
   console.log('\n   If you use Cloudflare, set the records to "DNS only" (grey cloud)');
   console.log('   so the certificate can be issued.\n');
 }
 
 // Step 2 — wait for DNS. Poll quietly; Enter forces a check; Ctrl+C leaves
 // the records in place and the command can be re-run later. Resolves once
-// the apex points here; says so if www does not yet.
+// the apex and www point here (only the apex for a subdomain).
 //
 // Ask public resolvers directly, not the machine's. Two reasons: the OS
 // resolver caches, so a record changed a minute ago can look unchanged here
 // 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, needTxt) {
+async function waitForDns(domain, ip, needTxt, kind) {
   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;
@@ -1144,6 +1214,12 @@ async function waitForDns(domain, ip, needTxt) {
     return false;
   };
   let apexOk = false, wwwOk = false, txtOk = !needTxt;
+  // The server connects a domain of its own with www or not at all (since
+  // 2026-11); only a subdomain (no NS records of its own) goes without it.
+  // By the dots, not "resolveNs says ENODATA": a subdomain whose record is
+  // not added yet is NXDOMAIN, which read as a domain of its own and waited
+  // for www.
+  const subdomain = (kind || domainKind(domain)).subdomain;
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   let poke = null;
   rl.on('line', () => { if (poke) poke(); });
@@ -1155,18 +1231,15 @@ async function waitForDns(domain, ip, needTxt) {
       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)'}${needTxt ? `   ${mark(txtOk)} TXT ${txtOk ? 'found' : '(not yet)'}` : ''}      `);
-      if (apexOk && txtOk) break;
+      const wwwPart = subdomain ? '' : `   ${mark(wwwOk)} www ${www.length ? '→ ' + www.join(', ') : '(no record yet)'}`;
+      process.stdout.write(`\r   ${mark(apexOk)} ${domain} ${apex.length ? '→ ' + apex.join(', ') : '(no record yet)'}${wwwPart}${needTxt ? `   ${mark(txtOk)} TXT ${txtOk ? 'found' : '(not yet)'}` : ''}      `);
+      if (apexOk && txtOk && (wwwOk || subdomain)) break;
       await wait(15000);
     }
   } finally {
     rl.close();
   }
   console.log('\n');
-  if (!wwwOk) {
-    console.log('   www is not pointing here yet — connecting the apex only. Re-run');
-    console.log('   `nukebase domain ' + domain + '` later to add the www redirect.\n');
-  }
 }
 
 // nukebase logs [--follow]   the recent journal for the unit; --follow keeps
@@ -1649,7 +1722,9 @@ async function push() {
   if (storageUp.length) {
     console.log(`\n  File storage (${storageUp.length} file(s)):`);
     const meter = progressMeter(storageBytes);
-    storageFailed = await storage.upload(API, authHeaders, root, storageLocal, storageUp, (n) => meter.add(n));
+    try {
+      storageFailed = await storage.upload(API, authHeaders, root, storageLocal, storageUp, (n) => meter.add(n));
+    } catch (e) { meter.stop(); throw e; }
     meter.done();
     if (storageFailed.length) {
       console.error(`\n❌ ${storageFailed.length} file(s) did not reach the storage; push again to send them:`);
@@ -2415,7 +2490,9 @@ async function backup() {
   if (storageChanged.length) {
     console.log(`\n   File storage (${storageChanged.length} file(s)):`);
     const meter = progressMeter(storageBytes);
-    storageFailed = await storage.download(API, authHeaders, dest, store.files, storageChanged, () => meter.counter());
+    try {
+      storageFailed = await storage.download(API, authHeaders, dest, store.files, storageChanged, () => meter.counter());
+    } catch (e) { meter.stop(); throw e; }
     meter.done();
   }
 

package/lib/storage.js

@@ -50,8 +50,12 @@ async function manifest(API, authHeaders) {
 }
 
 // One request to the bucket, IPv4, failing on IDLE_MS without progress.
-// Resolves { status, headers, stream } once headers arrive.
-function request(method, url, body) {
+// Resolves { status, headers, stream } once headers arrive. With onSent, the
+// body goes out in SLICE pieces and onSent(n) is called as each one is handed
+// to the network, so the progress line moves while a part uploads instead of
+// jumping by a whole part (up to 16 MB) when it finishes.
+const SLICE = 256 * 1024;
+function request(method, url, body, onSent) {
   return new Promise((resolve, reject) => {
     const u = new URL(url);
     const mod = u.protocol === 'http:' ? http : https;
@@ -64,10 +68,37 @@ function request(method, url, body) {
     });
     req.setTimeout(IDLE_MS, () => req.destroy(new Error('the storage stopped answering')));
     req.on('error', reject);
-    req.end(body || undefined);
+    if (!body || !onSent) { req.end(body || undefined); return; }
+    let off = 0;
+    const writeMore = () => {
+      while (off < body.length) {
+        const end = Math.min(off + SLICE, body.length);
+        const n = end - off;
+        const more = req.write(body.subarray(off, end), (err) => { if (!err) onSent(n); });
+        off = end;
+        if (!more) { req.once('drain', writeMore); return; }
+      }
+      req.end();
+    };
+    writeMore();
   });
 }
 
+// One upload attempt whose bytes are reported as they go out. If the attempt
+// fails, what it reported is taken back, so a retried part is not counted
+// twice and the line cannot pass the total.
+async function counted(onBytes, attempt) {
+  let n = 0;
+  let over = false;   // a write callback landing after the failure adds nothing
+  try {
+    return await attempt((k) => { if (over) return; n += k; onBytes(k); });
+  } catch (e) {
+    over = true;
+    if (n) onBytes(-n);
+    throw e;
+  }
+}
+
 async function retry(what, fn) {
   let last;
   for (let i = 0; i < TRIES; i++) {
@@ -214,12 +245,11 @@ async function upload(API, authHeaders, root, local, keys, onBytes) {
       const plan = await postJson(API, authHeaders, '/storage-upload', { key, size });
       if (plan.url) {
         const body = fs.readFileSync(file);
-        await retry(key, async () => {
-          const r = await request('PUT', plan.url, body);
+        await retry(key, () => counted(onBytes, async (onSent) => {
+          const r = await request('PUT', plan.url, body, onSent);
           r.stream.resume();
           if (r.status !== 200) throw new Error(`HTTP ${r.status}`);
-        });
-        onBytes(size);
+        }));
         sent.push(key);
         return;
       }
@@ -230,13 +260,12 @@ async function upload(API, authHeaders, root, local, keys, onBytes) {
           const len = Math.min(plan.partSize, size - i * plan.partSize);
           const buf = Buffer.alloc(len);
           fs.readSync(fd, buf, 0, len, i * plan.partSize);
-          await retry(`${key} part ${i + 1}`, async () => {
-            const r = await request('PUT', url, buf);
+          await retry(`${key} part ${i + 1}`, () => counted(onBytes, async (onSent) => {
+            const r = await request('PUT', url, buf, onSent);
             r.stream.resume();
             if (r.status !== 200 || !r.headers.etag) throw new Error(`HTTP ${r.status}`);
             etags[i] = r.headers.etag;
-          });
-          onBytes(len);
+          }));
         });
         await postJson(API, authHeaders, '/storage-upload-complete', { key, uploadId: plan.uploadId, etags });
         sent.push(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nukebase",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "description": "NukeBase CLI: create, deploy and manage NukeBase projects",
   "bin": {
     "nukebase": "bin/nukebase.js"