feat: Add LXC container backup functionality

prisma/migrations/20251118091618_add_backups_and_pbs_credentials/migration.sql

@@ -0,0 +1,41 @@
+-- CreateTable
+CREATE TABLE IF NOT EXISTS "backups" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "container_id" TEXT NOT NULL,
+    "server_id" INTEGER NOT NULL,
+    "hostname" TEXT NOT NULL,
+    "backup_name" TEXT NOT NULL,
+    "backup_path" TEXT NOT NULL,
+    "size" BIGINT,
+    "created_at" DATETIME,
+    "storage_name" TEXT NOT NULL,
+    "storage_type" TEXT NOT NULL,
+    "discovered_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "backups_server_id_fkey" FOREIGN KEY ("server_id") REFERENCES "servers" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE IF NOT EXISTS "pbs_storage_credentials" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "server_id" INTEGER NOT NULL,
+    "storage_name" TEXT NOT NULL,
+    "pbs_ip" TEXT NOT NULL,
+    "pbs_datastore" TEXT NOT NULL,
+    "pbs_password" TEXT NOT NULL,
+    "pbs_fingerprint" TEXT NOT NULL,
+    "created_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" DATETIME NOT NULL,
+    CONSTRAINT "pbs_storage_credentials_server_id_fkey" FOREIGN KEY ("server_id") REFERENCES "servers" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE INDEX IF NOT EXISTS "backups_container_id_idx" ON "backups"("container_id");
+
+-- CreateIndex
+CREATE INDEX IF NOT EXISTS "backups_server_id_idx" ON "backups"("server_id");
+
+-- CreateIndex
+CREATE INDEX IF NOT EXISTS "pbs_storage_credentials_server_id_idx" ON "pbs_storage_credentials"("server_id");
+
+-- CreateIndex
+CREATE UNIQUE INDEX IF NOT EXISTS "pbs_storage_credentials_server_id_storage_name_key" ON "pbs_storage_credentials"("server_id", "storage_name");

prisma/schema.prisma

@@ -41,6 +41,8 @@ model Server {
   ssh_key_path       String?
   key_generated      Boolean?           @default(false)
   installed_scripts  InstalledScript[]
+  backups            Backup[]
+  pbs_credentials    PBSStorageCredential[]
 
   @@map("servers")
 }
@@ -96,6 +98,42 @@ model LXCConfig {
   @@map("lxc_configs")
 }
 
+model Backup {
+  id                Int       @id @default(autoincrement())
+  container_id      String
+  server_id         Int
+  hostname          String
+  backup_name       String
+  backup_path       String
+  size              BigInt?
+  created_at        DateTime?
+  storage_name      String
+  storage_type      String    // 'local', 'storage', or 'pbs'
+  discovered_at     DateTime  @default(now())
+  server            Server    @relation(fields: [server_id], references: [id], onDelete: Cascade)
+
+  @@index([container_id])
+  @@index([server_id])
+  @@map("backups")
+}
+
+model PBSStorageCredential {
+  id                Int       @id @default(autoincrement())
+  server_id         Int
+  storage_name      String
+  pbs_ip            String
+  pbs_datastore     String
+  pbs_password      String
+  pbs_fingerprint   String
+  created_at        DateTime  @default(now())
+  updated_at        DateTime  @updatedAt
+  server            Server    @relation(fields: [server_id], references: [id], onDelete: Cascade)
+
+  @@unique([server_id, storage_name])
+  @@index([server_id])
+  @@map("pbs_storage_credentials")
+}
+
 model Repository {
   id          Int      @id @default(autoincrement())
   url         String   @unique

restore.log

@@ -0,0 +1,10 @@
+Starting restore...
+Reading container configuration...
+Stopping container...
+Destroying container...
+Logging into PBS...
+Downloading backup from PBS...
+Packing backup folder...
+Restoring container...
+Cleaning up temporary files...
+Restore completed successfully

server.js

@@ -276,13 +276,15 @@ class ScriptExecutionHandler {
    * @param {WebSocketMessage} message
    */
   async handleMessage(ws, message) {
-    const { action, scriptPath, executionId, input, mode, server, isUpdate, isShell, containerId } = message;
+    const { action, scriptPath, executionId, input, mode, server, isUpdate, isShell, isBackup, containerId, storage, backupStorage } = message;
 
     switch (action) {
       case 'start':
         if (scriptPath && executionId) {
-          if (isUpdate && containerId) {
-            await this.startUpdateExecution(ws, containerId, executionId, mode, server);
+          if (isBackup && containerId && storage) {
+            await this.startBackupExecution(ws, containerId, executionId, storage, mode, server);
+          } else if (isUpdate && containerId) {
+            await this.startUpdateExecution(ws, containerId, executionId, mode, server, backupStorage);
           } else if (isShell && containerId) {
             await this.startShellExecution(ws, containerId, executionId, mode, server);
           } else {
@@ -660,18 +662,220 @@ class ScriptExecutionHandler {
     }
   }
 
+  /**
+   * Start backup execution
+   * @param {ExtendedWebSocket} ws
+   * @param {string} containerId
+   * @param {string} executionId
+   * @param {string} storage
+   * @param {string} mode
+   * @param {ServerInfo|null} server
+   */
+  async startBackupExecution(ws, containerId, executionId, storage, mode = 'local', server = null) {
+    try {
+      // Send start message
+      this.sendMessage(ws, {
+        type: 'start',
+        data: `Starting backup for container ${containerId} to storage ${storage}...`,
+        timestamp: Date.now()
+      });
+
+      if (mode === 'ssh' && server) {
+        await this.startSSHBackupExecution(ws, containerId, executionId, storage, server);
+      } else {
+        this.sendMessage(ws, {
+          type: 'error',
+          data: 'Backup is only supported via SSH',
+          timestamp: Date.now()
+        });
+      }
+    } catch (error) {
+      this.sendMessage(ws, {
+        type: 'error',
+        data: `Failed to start backup: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp: Date.now()
+      });
+    }
+  }
+
+  /**
+   * Start SSH backup execution
+   * @param {ExtendedWebSocket} ws
+   * @param {string} containerId
+   * @param {string} executionId
+   * @param {string} storage
+   * @param {ServerInfo} server
+   * @param {Function} [onComplete] - Optional callback when backup completes
+   */
+  startSSHBackupExecution(ws, containerId, executionId, storage, server, onComplete = null) {
+    const sshService = getSSHExecutionService();
+
+    return new Promise((resolve, reject) => {
+      try {
+        const backupCommand = `vzdump ${containerId} --storage ${storage} --mode snapshot`;
+
+        // Wrap the onExit callback to resolve our promise
+        let promiseResolved = false;
+
+        sshService.executeCommand(
+          server,
+          backupCommand,
+          /** @param {string} data */
+          (data) => {
+            this.sendMessage(ws, {
+              type: 'output',
+              data: data,
+              timestamp: Date.now()
+            });
+          },
+          /** @param {string} error */
+          (error) => {
+            this.sendMessage(ws, {
+              type: 'error',
+              data: error,
+              timestamp: Date.now()
+            });
+          },
+          /** @param {number} code */
+          (code) => {
+            // Don't send 'end' message here if this is part of a backup+update flow
+            // The update flow will handle completion messages
+            const success = code === 0;
+
+            if (!success) {
+              this.sendMessage(ws, {
+                type: 'error',
+                data: `Backup failed with exit code: ${code}`,
+                timestamp: Date.now()
+              });
+            }
+
+            // Send a completion message (but not 'end' type to avoid stopping terminal)
+            this.sendMessage(ws, {
+              type: 'output',
+              data: `\n[Backup ${success ? 'completed' : 'failed'} with exit code: ${code}]\n`,
+              timestamp: Date.now()
+            });
+
+            if (onComplete) onComplete(success);
+
+            // Resolve the promise when backup completes
+            // Use setImmediate to ensure resolution happens in the right execution context
+            if (!promiseResolved) {
+              promiseResolved = true;
+              const result = { success, code };
+
+              // Use setImmediate to ensure promise resolution happens in the next tick
+              // This ensures the await in startUpdateExecution can properly resume
+              setImmediate(() => {
+                try {
+                  resolve(result);
+                } catch (resolveError) {
+                  console.error('Error resolving backup promise:', resolveError);
+                  reject(resolveError);
+                }
+              });
+            }
+
+            this.activeExecutions.delete(executionId);
+          }
+        ).then((execution) => {
+          // Store the execution
+          this.activeExecutions.set(executionId, { 
+            process: /** @type {any} */ (execution).process, 
+            ws
+          });
+          // Note: Don't resolve here - wait for onExit callback
+        }).catch((error) => {
+          console.error('Error starting backup execution:', error);
+          this.sendMessage(ws, {
+            type: 'error',
+            data: `SSH backup execution failed: ${error instanceof Error ? error.message : String(error)}`,
+            timestamp: Date.now()
+          });
+          if (onComplete) onComplete(false);
+          if (!promiseResolved) {
+            promiseResolved = true;
+            reject(error);
+          }
+        });
+
+      } catch (error) {
+        console.error('Error in startSSHBackupExecution:', error);
+        this.sendMessage(ws, {
+          type: 'error',
+          data: `SSH backup execution failed: ${error instanceof Error ? error.message : String(error)}`,
+          timestamp: Date.now()
+        });
+        if (onComplete) onComplete(false);
+        reject(error);
+      }
+    });
+  }
+
   /**
    * Start update execution (pct enter + update command)
    * @param {ExtendedWebSocket} ws
    * @param {string} containerId
    * @param {string} executionId
    * @param {string} mode
    * @param {ServerInfo|null} server
+   * @param {string} [backupStorage] - Optional storage to backup to before update
    */
-  async startUpdateExecution(ws, containerId, executionId, mode = 'local', server = null) {
+  async startUpdateExecution(ws, containerId, executionId, mode = 'local', server = null, backupStorage = null) {
     try {
+      // If backup storage is provided, run backup first
+      if (backupStorage && mode === 'ssh' && server) {
+        this.sendMessage(ws, {
+          type: 'start',
+          data: `Starting backup before update for container ${containerId}...`,
+          timestamp: Date.now()
+        });
+
+        // Create a separate execution ID for backup
+        const backupExecutionId = `backup_${executionId}`;
+
+        // Run backup and wait for it to complete
+        try {
+          const backupResult = await this.startSSHBackupExecution(
+            ws, 
+            containerId, 
+            backupExecutionId, 
+            backupStorage, 
+            server
+          );
+
+          // Backup completed (successfully or not)
+          if (!backupResult || !backupResult.success) {
+            // Backup failed, but we'll still allow update (per requirement 1b)
+            this.sendMessage(ws, {
+              type: 'output',
+              data: '\n⚠️ Backup failed, but proceeding with update as requested...\n',
+              timestamp: Date.now()
+            });
+          } else {
+            // Backup succeeded
+            this.sendMessage(ws, {
+              type: 'output',
+              data: '\n✅ Backup completed successfully. Starting update...\n',
+              timestamp: Date.now()
+            });
+          }
+        } catch (error) {
+          console.error('Backup error before update:', error);
+          // Backup failed to start, but allow update to proceed
+          this.sendMessage(ws, {
+            type: 'output',
+            data: `\n⚠️ Backup error: ${error instanceof Error ? error.message : String(error)}. Proceeding with update...\n`,
+            timestamp: Date.now()
+          });
+        }
+
+        // Small delay before starting update
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
 
-      // Send start message
+      // Send start message for update (only if we're actually starting an update)
       this.sendMessage(ws, {
         type: 'start',
         data: `Starting update for container ${containerId}...`,