vibecarbon 0.5.0 → 0.6.0

package/src/backup.js

@@ -13,6 +13,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import * as p from '@clack/prompts';
+import { formatInstant } from './lib/backup-format.js';
 import { downloadS3Backup, listS3Backups } from './lib/backup-s3.js';
 import { renderHelp } from './lib/cli/help.js';
 import { parseFlags } from './lib/cli/parse-flags.js';
@@ -30,7 +31,6 @@ import { getS3Credentials } from './lib/hetzner-guided-setup.js';
 import { requireLicense } from './lib/licensing/index.js';
 import { ensureOperatorIpAccess } from './lib/operator-ip.js';
 import { perfAsync } from './lib/perf.js';
-import { listPodBackups } from './lib/pod-backups.js';
 import { assertInProjectDir } from './lib/project-guard.js';
 import {
   getPostgresPod,
@@ -43,6 +43,7 @@ import {
 import { createTracker } from './lib/tracker.js';
 import { validateBackupFilename } from './lib/validators.js';
 import { VERSION } from './lib/version.js';
+import { listWalgBackups } from './lib/walg-backups.js';
 
 // ============================================================================
 // COMMAND SPEC — single source of truth for argv parsing AND help output.
@@ -103,17 +104,21 @@ const ACTION_CHOICES = [
 // ============================================================================
 
 async function downloadPodBackup(ip, sshKeyPath, filename) {
-  const pod = getPostgresPod(ip, sshKeyPath);
+  const pod = await getPostgresPod(ip, sshKeyPath);
 
   // Copy from pod to host
-  sshKubectl(ip, sshKeyPath, ['cp', `vibecarbon/${pod}:/backups/${filename}`, `/tmp/${filename}`]);
+  await sshKubectl(ip, sshKeyPath, [
+    'cp',
+    `vibecarbon/${pod}:/backups/${filename}`,
+    `/tmp/${filename}`,
+  ]);
 
   // SCP from host to local
   const localPath = join(process.cwd(), filename);
-  scpDownload(ip, sshKeyPath, `/tmp/${filename}`, localPath);
+  await scpDownload(ip, sshKeyPath, `/tmp/${filename}`, localPath);
 
   // Clean up remote temp file
-  sshRun(ip, sshKeyPath, ['rm', '-f', `/tmp/${filename}`]);
+  await sshRun(ip, sshKeyPath, ['rm', '-f', `/tmp/${filename}`]);
 
   return localPath;
 }
@@ -122,7 +127,7 @@ async function downloadPodBackup(ip, sshKeyPath, filename) {
 // K8S JOB BACKUP (triggers CronJob-based backup)
 // ============================================================================
 
-function triggerBackupJob(ip, sshKeyPath) {
+async function triggerBackupJob(ip, sshKeyPath) {
   const timestamp = new Date()
     .toISOString()
     .replace(/[:.]/g, '-')
@@ -132,7 +137,7 @@ function triggerBackupJob(ip, sshKeyPath) {
   const jobName = `backup-manual-${timestamp}`;
 
   // Create a one-off Job from the CronJob template
-  sshKubectl(ip, sshKeyPath, [
+  await sshKubectl(ip, sshKeyPath, [
     'create',
     'job',
     `--from=cronjob/backup`,
@@ -156,7 +161,7 @@ function triggerBackupJob(ip, sshKeyPath) {
   // diagnostic returned "No pod matching" because controller-manager already
   // GC'd the failed Pod within the ~1s window between SSH sessions).
   try {
-    sshRunScript(
+    await sshRunScript(
       ip,
       sshKeyPath,
       `export KUBECONFIG=/etc/rancher/k3s/k3s.yaml
@@ -220,7 +225,7 @@ exit 1`,
     // run kubectl describe for runtime context that bare logs miss.
     let podDiag = '';
     try {
-      podDiag = sshRunScript(
+      podDiag = await sshRunScript(
         ip,
         sshKeyPath,
         `export KUBECONFIG=/etc/rancher/k3s/k3s.yaml
@@ -418,7 +423,7 @@ export async function run(args) {
   const s = tracker.spinner();
 
   if (action === 'list') {
-    await runList({ s, isCompose, useS3, s3Config, serverIp, sshKeyPath, projectName, envName });
+    await runList({ s, isCompose, serverIp, sshKeyPath, projectName, envName });
     p.outro('');
     return;
   }
@@ -517,83 +522,23 @@ async function resolveS3Config({ isCompose, envName, projectName }) {
   return s3Config;
 }
 
-async function runList({
-  s,
-  isCompose,
-  useS3,
-  s3Config,
-  serverIp,
-  sshKeyPath,
-  projectName,
-  envName,
-}) {
-  s.start('Listing backups');
-
-  if (isCompose) {
-    if (useS3) {
-      try {
-        const backups = await listS3Backups(s3Config);
-        s.stop('Backups retrieved from S3');
-        printBackupList(backups, envName);
-      } catch (error) {
-        s.stop('Failed to list S3 backups');
-        p.log.error(error.message);
-      }
-    } else {
-      try {
-        const output = sshRunScript(
-          serverIp,
-          sshKeyPath,
-          `ls -lhS /opt/${projectName}/backups/*_full.tar.gz 2>/dev/null || echo NO_BACKUPS`,
-        );
-        s.stop('Backups retrieved');
-
-        if (output === 'NO_BACKUPS' || !output.trim()) {
-          p.log.info('No backups found.');
-          p.log.info(`Create one with: ${c.info(`vibecarbon backup ${envName}`)}`);
-        } else {
-          const lines = output.trim().split('\n').filter(Boolean);
-          p.log.info(`${c.bold(`Backups for ${envName}`)} (${lines.length} found):`);
-          for (const line of lines) {
-            p.log.message(`  ${line}`);
-          }
-        }
-      } catch (error) {
-        s.stop('Failed to list backups');
-        p.log.error(error.message);
-      }
-    }
-    return;
-  }
-
-  // K8s
-  if (useS3) {
-    try {
-      const backups = await listS3Backups(s3Config);
-      s.stop('Backups retrieved from S3');
-      printBackupList(backups, envName);
-    } catch (error) {
-      s.stop('Failed to list S3 backups');
-      p.log.error(error.message);
-      process.exit(1);
-    }
-    return;
-  }
-
-  const backups = listPodBackups(serverIp, sshKeyPath, { sort: 'largest' });
-  s.stop('Backups retrieved');
-  printBackupList(backups, envName);
-}
+async function runList({ s, isCompose, serverIp, sshKeyPath, projectName, envName }) {
+  // List the actual wal-g base backups (the restorable ones) — NOT the legacy
+  // backups/*_full.tar.gz S3 objects, which wal-g neither writes nor restores.
+  s.start('Reading wal-g backups');
+  const backups = await listWalgBackups({ serverIp, sshKeyPath, projectName, isCompose });
+  s.stop('Backups read');
 
-function printBackupList(backups, envName) {
-  if (!backups || backups.length === 0) {
-    p.log.info('No backups found.');
+  if (backups.length === 0) {
+    p.log.info('No wal-g base backups found.');
     p.log.info(`Create one with: ${c.info(`vibecarbon backup ${envName}`)}`);
     return;
   }
-  p.log.info(`${c.bold(`Backups for ${envName}`)} (${backups.length} found):`);
-  for (const backup of backups) {
-    p.log.message(`  ${c.dim(backup.date.padEnd(22))} ${backup.size.padStart(10)}  ${backup.name}`);
+  p.log.info(
+    `${c.bold(`Backups for ${envName}`)} (${backups.length} base backup(s), newest first):`,
+  );
+  for (const b of backups) {
+    p.log.message(`  ${formatInstant(b.time).padEnd(22)} ${c.dim(b.name)}`);
   }
 }
 
@@ -614,7 +559,7 @@ async function runDownload({
       if (useS3) {
         await downloadS3Backup(s3Config, `backups/${source}`, localPath);
       } else {
-        scpDownload(serverIp, sshKeyPath, `/opt/${projectName}/backups/${source}`, localPath);
+        await scpDownload(serverIp, sshKeyPath, `/opt/${projectName}/backups/${source}`, localPath);
       }
       s.stop('Download complete');
       p.log.success(`Saved to ${c.bold(localPath)}`);
@@ -665,7 +610,7 @@ async function runCreate({
     s.start('Creating wal-g base backup...');
     try {
       const { backupCompose } = await import('./lib/deploy/compose/index.js');
-      backupCompose(serverIp, sshKeyPath, projectName, { retain: backupRetain });
+      await backupCompose(serverIp, sshKeyPath, projectName, { retain: backupRetain });
       // "uploaded to S3" wording matches the k8s path (line ~689) and the e2e
       // backup-step verification (which greps /uploaded to s3/i to confirm the
       // backup is durable before allowing destroy → restore).
@@ -683,8 +628,9 @@ async function runCreate({
   // K8s — trigger via CronJob template
   s.start('Creating backup (triggering Kubernetes Job)');
   try {
-    const jobName = await perfAsync('backup.triggerJob', async () =>
-      triggerBackupJob(serverIp, sshKeyPath),
+    const jobName = await perfAsync(
+      'backup.triggerJob',
+      async () => await triggerBackupJob(serverIp, sshKeyPath),
     );
     s.stop('Backup created');