nukebase 2.3.0 → 2.4.0

package/README.md

@@ -41,7 +41,7 @@ Push and pull carry it, so a fresh clone is already linked.
 ```
 nukebase create <name> [size] [email]   sizes: 128mb, 256mb, 512mb, 1gb
 nukebase link <name> [email]            connect a folder to an existing project
-nukebase push | pull | logs | rollback | backup | env push | domain | ...
+nukebase push | pull | logs | rollback | backup | restore | env push | domain | ...
 ```
 
 Run `nukebase help` for every command.

package/bin/nukebase.js

@@ -24,6 +24,7 @@ if (!(args.has('version') && !args.command)) {
 const ACCOUNT_COMMANDS = ['login', 'logout', 'accounts', 'use', 'whoami', 'create', 'link'];
 const PROJECT_COMMANDS = [
   'push', 'pull', 'update', 'rollback', 'restorepoints', 'restore-points', 'backup', 'env',
+  'restore', 'backups',
   'pause', 'restart', 'resume', 'delete', 'domain', 'logs', 'download',
   'regiontransfer', 'region-transfer'
 ];
@@ -69,7 +70,7 @@ In a project folder (runs as the account that owns the project)
   update                     refresh the NukeBase engine files
   backup [--out <dir>]       download the backup set from the server
   backup --storage           also the app's files in file storage (new or
-                             changed ones, straight from the storage)
+                             changed ones)
   env push                   make the hosted environment (process.env) equal
                              to ./.env, then restart the project
   env list [--show]          variable names set on the server
@@ -77,6 +78,13 @@ In a project folder (runs as the account that owns the project)
   rollback backup [id]       undo a push AND restore the backup set as it was
                              then; discards writes since
   rollback list              show restore points (also: restorepoints)
+  restore list               backups in file storage: database and code,
+                             every 4 hours and after each push, 30 days
+                             (also: backups)
+  restore <id>               put one back (--code-only / --data-only);
+                             what it replaces becomes a restore point
+  backup --from <id>         download one: its database into ./server/data,
+                             or everything with --out <dir>
   pause                      stop the project (base fee + disk still accrue)
   restart | resume           restart it; also resumes a paused project
   delete                     delete it on the server; asks for the name

package/lib/guide.js

@@ -103,6 +103,8 @@ Then, inside the project folder:
   npx nukebase domain email        send the app's emails from that domain
   npx nukebase rollback            undo the last push (their data is kept)
   npx nukebase backup              copy the app's data to this computer
+  npx nukebase restore list        the app's backups (database + code, 30 days)
+                                   (add --storage for the files it stores)
   npx nukebase env push            send secrets from .env to the server
   npx nukebase pause / restart     stop the app, or start it again
   npx nukebase help                every command

package/lib/project-commands.js

@@ -1521,7 +1521,8 @@ async function push() {
   const { remove, diskWarning } = synced;
   if (diskWarning) console.log('⚠️  ' + diskWarning);
 
-  // --include backup on a project with file storage: its files (server/files)
+  // --include backup on a project with file storage: its files (storage/ or
+  // server/files)
   // go straight to the storage, not to the server, and only the ones it lacks
   // or holds at another size. Nothing there is deleted.
   let store = null;
@@ -1539,7 +1540,8 @@ async function push() {
       storageUp = storage.changedLocal(storageLocal, store.files);
     }
   }
-  const inFilesDir = (f) => f === storage.FILES_DIR || f.startsWith(storage.FILES_DIR + '/');
+  const filesRel = storage.filesDir(root);
+  const inFilesDir = (f) => f === filesRel || f.startsWith(filesRel + '/');
   const upload = store && store.storage ? synced.upload.filter((f) => !inFilesDir(f)) : synced.upload;
   const storageBytes = storageUp.reduce((n, k) => n + storageLocal[k][0], 0);
 
@@ -1597,7 +1599,7 @@ async function push() {
       console.log('  Run `nukebase backup` first if you meant to restore a copy.');
     }
     if (store && store.storage) {
-      console.log(`\n  File storage: ${storageUp.length} file(s), ${(storageBytes / 1024 / 1024).toFixed(2)} MB from ${storage.FILES_DIR}`);
+      console.log(`\n  File storage: ${storageUp.length} file(s), ${(storageBytes / 1024 / 1024).toFixed(2)} MB from ${storage.filesDir(root)}`);
       console.log('  go straight to the storage (missing or changed ones only; nothing there is deleted).');
       storageUp.slice(0, 10).forEach(f => console.log('      ⇈ ' + f));
       if (storageUp.length > 10) console.log(`      ... and ${storageUp.length - 10} more`);
@@ -2254,6 +2256,7 @@ async function rollback() {
 // the working tree.
 async function backup() {
   await connectAndLogin();
+  if (args.get('from')) return backupFrom(args.get('from'));
 
   const dest = args.get('out') ? resolve(args.get('out')) : root;
 
@@ -2337,7 +2340,7 @@ async function backup() {
   }
 
   // File storage: a project whose files live in object storage. Listed always;
-  // downloaded with --storage, straight from the storage, new or changed only.
+  // downloaded with --storage, new or changed only.
   let store = null;
   let storageChanged = [];
   let storageBytes = 0;
@@ -2355,7 +2358,7 @@ async function backup() {
       storageBytes = storageChanged.reduce((n, k) => n + store.files[k][0], 0);
       if (!storageChanged.length) console.log('   ✓ Already up to date.');
       else {
-        console.log(`   ${storageChanged.length} changed, ${(storageBytes / 1024 / 1024).toFixed(2)} MB to download into ${storage.FILES_DIR}`);
+        console.log(`   ${storageChanged.length} changed, ${(storageBytes / 1024 / 1024).toFixed(2)} MB to download into ${storage.filesDir(dest)}`);
         storageChanged.slice(0, 10).forEach(f => console.log('     ↓ ' + f));
         if (storageChanged.length > 10) console.log(`     ... and ${storageChanged.length - 10} more`);
       }
@@ -2555,6 +2558,182 @@ async function envList() {
   process.exit(0);
 }
 
+// ---------------------------------------------------------------------------
+// Backups in file storage: restore, restore list, backup --from
+// ---------------------------------------------------------------------------
+// A project with file storage backs itself up into its own storage: its
+// database and code, every few hours and after each push, kept 30 days (the
+// engine does it, 1.12+). `restore list` shows them; `restore <id>` puts one
+// back on the server: the code at once, the database as the app starts
+// again. What it replaces is saved as a restore point first, so `nukebase
+// rollback backup <that id>` undoes it. `backup --from <id>` downloads one
+// instead.
+
+function ageOf(at) {
+  const h = (Date.now() - at) / 3600000;
+  return h < 1 ? `${Math.max(1, Math.round(h * 60))} minutes ago` : h < 48 ? `${h.toFixed(1)} hours ago` : `${(h / 24).toFixed(1)} days ago`;
+}
+
+async function listBackups() {
+  const res = await fetch(`${API}/backups`, {
+    method: 'POST', headers: authHeaders({ 'Content-Type': 'application/json' }), body: '{}'
+  });
+  if (res.status === 401) authExpired();
+  if (res.status === 404) {
+    console.error('❌ This region does not keep backups in file storage yet.');
+    process.exit(1);
+  }
+  if (!res.ok) {
+    console.error('❌ Could not list backups:', res.status, await res.text());
+    process.exit(1);
+  }
+  return res.json();
+}
+
+async function restoreCommand() {
+  await connectAndLogin();
+  const first = args.positional[0];
+  const { storage: has, backups, late } = await listBackups();
+  if (!has) {
+    console.log(`\n${project} keeps its files on the server's disk, so it has no backups in file storage.`);
+    console.log('  Its daily backups are on the server (server/backup); restore points: nukebase rollback list\n');
+    process.exit(0);
+  }
+
+  if (!first || first === 'list' || command === 'backups') {
+    if (!backups.length) {
+      console.log(`\nNo backups of ${project} yet. They are made a few minutes after each start`);
+      console.log('and every 4 hours (engine 1.12+: nukebase update, then push).\n');
+      process.exit(0);
+    }
+    console.log(`\nBackups of ${project} (kept 30 days):\n`);
+    for (const b of backups) {
+      console.log(`  ${b.id}   ${new Date(b.at).toISOString().replace('T', ' ').slice(0, 19)}   ${ageOf(b.at)}`);
+    }
+    if (late) console.log('\n  ⚠️  No backup for over 9 hours: check the logs (nukebase logs).');
+    console.log('\n  nukebase restore <id>              the database and the code as they were then');
+    console.log('  nukebase restore <id> --code-only  only the code (keeps live data)');
+    console.log('  nukebase restore <id> --data-only  only the database');
+    console.log('  nukebase backup --from <id>        download it instead (--out <dir> for everything)\n');
+    process.exit(0);
+  }
+
+  const target = backups.find((b) => b.id === first);
+  if (!target) {
+    console.error(`❌ No such backup: ${first}`);
+    console.error("   Run 'nukebase restore list' to see them.");
+    process.exit(1);
+  }
+  const code = !args.has('data-only');
+  const data = !args.has('code-only');
+  if (!code && !data) {
+    console.error('❌ --code-only and --data-only together leave nothing to restore.');
+    process.exit(1);
+  }
+
+  console.log(`\n⏪ Restoring ${project} to backup ${target.id}`);
+  console.log(`   taken ${new Date(target.at).toISOString().replace('T', ' ').slice(0, 19)}  (${ageOf(target.at)})`);
+  console.log(`   ${[data && 'the database', code && 'the code'].filter(Boolean).join(' and ')}; the project restarts`);
+  console.log('   What is replaced is saved as a restore point first, so it can be undone.');
+  if (data) {
+    console.log('\n' + '─'.repeat(66));
+    console.log('  ⚠️  THIS DISCARDS DATA. Read before continuing.');
+    console.log('─'.repeat(66));
+    console.log(`\n  Every write of the last ${ageOf(target.at).replace(' ago', '')} is lost from the live app`);
+    console.log("  (kept only in that restore point). The app's stored files are not");
+    console.log('  changed. If you only need the code back, press Ctrl+C and run:');
+    console.log(`      nukebase restore ${target.id} --code-only\n`);
+    const typed = await confirmTyped(project, `  Type the project name (${project}) to confirm: `);
+    if (!typed) { console.log('Aborted.'); process.exit(0); }
+  } else {
+    const ok = await confirm('\nContinue? (y/n) ');
+    if (!ok) { console.log('Aborted.'); process.exit(0); }
+  }
+
+  const res = await fetch(`${API}/backup-restore`, {
+    method: 'POST',
+    headers: authHeaders({ 'Content-Type': 'application/json' }),
+    body: JSON.stringify({ id: target.id, data, code, confirm: project })
+  });
+  if (!res.ok) {
+    console.error('\n❌ Restore failed:', res.status, await res.text());
+    process.exit(1);
+  }
+  const result = await res.json();
+  console.log(`\n✅ Restored backup ${target.id}`);
+  if (code) console.log(`   ${result.codeFiles} code file(s) put back`);
+  if (data) console.log(result.database ? '   the database is restored as the app starts (see the logs below)' : '   ⚠️  the database could not be marked for restore');
+  if (result.failures && result.failures.length) {
+    console.log(`   ⚠️  ${result.failures.length} file(s) could not be restored:`);
+    result.failures.slice(0, 10).forEach((f) => console.log('      ! ' + f));
+  }
+  if (result.undoId) {
+    console.log(`\n   What it replaced is restore point ${result.undoId}`);
+    console.log(`   Undo with: nukebase rollback backup ${result.undoId}`);
+  }
+  if (AUTO_YES) { await tailLogsUntilSettled(); process.exit(0); }
+  watchLogs();
+}
+
+// backup --from <id>: the backup's database into ./server/data, as a plain
+// backup does; with --out <dir>, everything it holds (code too) into that
+// folder, on links the server signs (served by the server).
+async function backupFrom(id) {
+  const res = await fetch(`${API}/backup-links`, {
+    method: 'POST',
+    headers: authHeaders({ 'Content-Type': 'application/json' }),
+    body: JSON.stringify({ id })
+  });
+  if (res.status === 401) authExpired();
+  if (!res.ok) {
+    console.error(`❌ Could not read backup ${id}:`, res.status, await res.text());
+    if (res.status === 404) console.error("   Run 'nukebase restore list' to see the backups.");
+    process.exit(1);
+  }
+  const snap = await res.json();
+  const out = args.get('out') ? resolve(args.get('out')) : null;
+  const entries = Object.entries(snap.files).filter(([rel]) => out || rel.startsWith('server/data/'));
+  const total = entries.reduce((n, [, f]) => n + (f.size || 0), 0);
+  console.log(`\n💾 Backup ${snap.id} of ${project}  (${ageOf(snap.at)})`);
+  console.log(`   ${entries.length} file(s), ${(total / 1024 / 1024).toFixed(2)} MB` + (out ? `, into ${out}` : ', its database, into ./server/data'));
+  if (!out && existsSync(join(root, 'server', 'data'))) {
+    console.log('   Your local ./server/data is moved to ./server/backup/before-' + snap.id);
+  }
+  if (!entries.length) { console.log('\n   Nothing to download.\n'); process.exit(0); }
+  const ok = await confirm('\nContinue? (y/n) ');
+  if (!ok) { console.log('Aborted.'); process.exit(0); }
+
+  // The database goes to a folder in server/backup (excluded from push) and
+  // replaces ./server/data only once all of it is here.
+  const fsm = require('fs');
+  const staging = out || join(root, 'server', 'backup', 'from-' + snap.id);
+  const target = (rel) => out ? join(out, ...rel.split('/')) : join(staging, ...rel.slice('server/data/'.length).split('/'));
+  if (!out) fsm.rmSync(staging, { recursive: true, force: true });
+  const meter = progressMeter(total);
+  const failed = [];
+  await storage.pool(entries, 4, async ([rel, f]) => {
+    const file = target(rel);
+    if (!resolve(file).startsWith(resolve(staging) + sep)) { failed.push(`${rel}: outside the folder`); return; }
+    try { await storage.fetchTo(rel, f.url, file, () => meter.counter()); } catch (e) { failed.push(`${rel}: ${e.message}`); }
+  });
+  meter.done();
+  if (failed.length) {
+    console.error(`\n❌ ${failed.length} file(s) failed; nothing was replaced:`);
+    failed.slice(0, 10).forEach((f) => console.error('     ' + f));
+    process.exit(1);
+  }
+  if (!out) {
+    const live = join(root, 'server', 'data');
+    const aside = join(root, 'server', 'backup', 'before-' + snap.id);
+    fsm.rmSync(aside, { recursive: true, force: true });
+    if (existsSync(live)) fsm.renameSync(live, aside);
+    fsm.renameSync(staging, live);
+  }
+  console.log(`\n✅ Backup ${snap.id} downloaded` + (out ? ` into ${out}` : ' into ./server/data'));
+  if (!out) console.log('   To send it back up:  nukebase push --include backup\n');
+  process.exit(0);
+}
+
 // bin/nukebase.js has already checked the command name.
 const run = (fn) => fn().catch(err => { console.error('❌', err.message); process.exit(1); });
 if (command === 'push' && args.positional[0] === 'env') {
@@ -2582,6 +2761,8 @@ if (command === 'push' && args.positional[0] === 'env') {
   run(rollback);
 } else if (command === 'backup') {
   run(backup);
+} else if (command === 'restore' || command === 'backups') {
+  run(restoreCommand);
 } else if (command === 'pause') {
   run(pauseProject);
 } else if (command === 'restart' || command === 'resume') {

package/lib/storage.js

@@ -1,9 +1,13 @@
 // Object storage for `nukebase backup --storage` and `nukebase push --include
 // backup`. A project with object storage keeps its files (what the app stores
-// with setFile) in a bucket instead of server/files. They move straight between
-// this machine and the bucket through links the server signs for one file and
-// one hour; none of the bytes pass through the project's server. Locally they
-// live where a project without storage keeps them: server/files/<path>.
+// with setFile) in a bucket instead of server/files. Uploads go straight from
+// this machine to the bucket through links the server signs for one file and
+// one hour. Downloads come through the server, on links it signs the same way:
+// the storage lets only the project's own key read what the app wrote, and
+// that key works only from the server. Locally they
+// live where a project without storage keeps them: storage/<path> in projects
+// made from the engine 1.12 template (marked by storage/$nukebase),
+// server/files/<path> before.
 //
 // Every transfer is IPv4: the storage provider stalls parallel uploads over
 // IPv6 (measured from the server: 13 of 18 stalled, against none over IPv4).
@@ -14,6 +18,12 @@ const { join, dirname, relative, sep } = require('path');
 const { pipeline } = require('stream/promises');
 
 const FILES_DIR = 'server/files';
+// The project's file folder, relative to root: the engine and the server pick
+// the same way.
+function filesDir(root) {
+  try { if (fs.statSync(join(root, 'storage', '$nukebase')).isFile()) return 'storage'; } catch {}
+  return FILES_DIR;
+}
 const IDLE_MS = 30000;
 const TRIES = 4;
 const PARALLEL = 6;
@@ -90,43 +100,55 @@ async function links(API, authHeaders, keys) {
   return out;
 }
 
-// Which bucket files differ from the local copy under dest/server/files: by
-// size, or by an mtime more than a second apart (a download sets the local
-// mtime to the bucket's).
+// Which bucket files differ from the local copy in the file folder: by size,
+// or by being newer in the bucket than here by more than a second. A download
+// sets the local mtime to the bucket's, and an upload sets it to when the
+// bucket got it, so neither is fetched again.
 function changedRemote(dest, files) {
+  const dir = filesDir(dest);
   return Object.keys(files).filter((key) => {
-    const local = join(dest, FILES_DIR, ...key.split('/'));
+    const local = join(dest, dir, ...key.split('/'));
     let st;
     try { st = fs.statSync(local); } catch { return true; }
     const [size, mtime] = files[key];
-    return st.size !== size || Math.abs(Math.floor(st.mtimeMs / 1000) - mtime) > 1;
+    return st.size !== size || mtime > Math.floor(st.mtimeMs / 1000) + 1;
   });
 }
 
-// Download `keys` into dest/server/files. Each file is written to a .part
-// beside it and renamed when complete, so an interrupted run leaves no torn
-// file. counter() is a pass-through that counts bytes for the progress line.
+// One URL into `target`, through a .part renamed when complete, so an
+// interrupted run leaves no torn file.
+async function fetchTo(what, url, target, counter) {
+  fs.mkdirSync(dirname(target), { recursive: true });
+  const part = target + '.part';
+  try {
+    await retry(what, async () => {
+      const r = await request('GET', url);
+      if (r.status !== 200) { r.stream.resume(); throw new Error(`HTTP ${r.status}`); }
+      await pipeline(r.stream, counter(), fs.createWriteStream(part));
+    });
+    fs.renameSync(part, target);
+  } catch (e) {
+    try { fs.unlinkSync(part); } catch {}
+    throw e;
+  }
+}
+
+// Download `keys` into the file folder under dest. counter() is a
+// pass-through that counts bytes for the progress line.
 async function download(API, authHeaders, dest, files, keys, counter) {
   const failed = [];
+  const dir = filesDir(dest);
   for (let i = 0; i < keys.length; i += 500) {
     const batch = keys.slice(i, i + 500);
     const urls = await links(API, authHeaders, batch);   // an hour each: fetched per batch
     await pool(batch, PARALLEL, async (key) => {
-      const target = join(dest, FILES_DIR, ...key.split('/'));
-      if (!target.startsWith(join(dest, FILES_DIR) + sep)) return;
-      fs.mkdirSync(dirname(target), { recursive: true });
-      const part = target + '.part';
+      const target = join(dest, dir, ...key.split('/'));
+      if (!target.startsWith(join(dest, dir) + sep)) return;
       try {
-        await retry(key, async () => {
-          const r = await request('GET', urls[key]);
-          if (r.status !== 200) { r.stream.resume(); throw new Error(`HTTP ${r.status}`); }
-          await pipeline(r.stream, counter(), fs.createWriteStream(part));
-        });
-        fs.renameSync(part, target);
+        await fetchTo(key, urls[key], target, counter);
         const mtime = files[key][1];
         if (mtime) fs.utimesSync(target, mtime, mtime);
       } catch (e) {
-        try { fs.unlinkSync(part); } catch {}
         failed.push(e.message);
       }
     });
@@ -134,11 +156,11 @@ async function download(API, authHeaders, dest, files, keys, counter) {
   return failed;
 }
 
-// The local files a restore would send: everything under root/server/files
-// except names the engine reserves ("$...", its index and spool) and partial
+// The local files a restore would send: everything in the file folder except
+// names the engine reserves ("$...", its index and spool) and partial
 // downloads, as { key: [size, mtime] }.
 function localFiles(root) {
-  const base = join(root, FILES_DIR);
+  const base = join(root, filesDir(root));
   const out = {};
   const walk = (dir) => {
     let ents;
@@ -177,11 +199,16 @@ async function postJson(API, authHeaders, path, body) {
   return res.json();
 }
 
-// Send each key from root/server/files to the bucket. Returns the failures.
+// Send each key from the file folder to the bucket. Returns the failures.
+// Each file sent then takes the bucket's date for it as its mtime, the way a
+// download does, so neither `backup --storage` nor the next push moves it
+// again.
 async function upload(API, authHeaders, root, local, keys, onBytes) {
   const failed = [];
+  const dir = filesDir(root);
+  const sent = [];
   await pool(keys, 4, async (key) => {
-    const file = join(root, FILES_DIR, ...key.split('/'));
+    const file = join(root, dir, ...key.split('/'));
     const size = local[key][0];
     try {
       const plan = await postJson(API, authHeaders, '/storage-upload', { key, size });
@@ -193,6 +220,7 @@ async function upload(API, authHeaders, root, local, keys, onBytes) {
           if (r.status !== 200) throw new Error(`HTTP ${r.status}`);
         });
         onBytes(size);
+        sent.push(key);
         return;
       }
       const fd = fs.openSync(file, 'r');
@@ -211,6 +239,7 @@ async function upload(API, authHeaders, root, local, keys, onBytes) {
           onBytes(len);
         });
         await postJson(API, authHeaders, '/storage-upload-complete', { key, uploadId: plan.uploadId, etags });
+        sent.push(key);
       } catch (e) {
         await postJson(API, authHeaders, '/storage-upload-complete', { key, uploadId: plan.uploadId, abort: true }).catch(() => {});
         throw e;
@@ -221,7 +250,16 @@ async function upload(API, authHeaders, root, local, keys, onBytes) {
       failed.push(`${key}: ${e.message}`);
     }
   });
+  if (sent.length) {
+    try {
+      const after = await manifest(API, authHeaders);
+      for (const key of sent) {
+        const r = after && after.files[key];
+        if (r && r[1]) fs.utimesSync(join(root, dir, ...key.split('/')), r[1], r[1]);
+      }
+    } catch {}   // only the next run's comparison suffers
+  }
   return failed;
 }
 
-module.exports = { FILES_DIR, manifest, changedRemote, download, localFiles, changedLocal, upload };
+module.exports = { FILES_DIR, filesDir, manifest, changedRemote, download, localFiles, changedLocal, upload, fetchTo, pool };

package/package.json

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