auramaxx 1.0.0-alpha.4

package/server/routes/backup.ts

@@ -0,0 +1,340 @@
+import { Router, Request, Response } from 'express';
+import { requireWalletAuth } from '../middleware/auth';
+import { requireAdmin } from '../lib/permissions';
+import { readdir, stat, copyFile, unlink, rename } from 'fs/promises';
+import { join, dirname } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+import { DATA_PATHS, getDbPath } from '../lib/config';
+import { logger } from '../lib/logger';
+import Database from 'better-sqlite3';
+
+const router = Router();
+
+export function getBackupsDir(): string {
+  return join(dirname(getDbPath()), 'backups');
+}
+
+export function ensureBackupsDir(): void {
+  const dir = getBackupsDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * Run WAL checkpoint to flush all data to the main DB file.
+ */
+function walCheckpoint(dbPath: string): void {
+  const db = new Database(dbPath, { readonly: false });
+  try {
+    db.pragma('wal_checkpoint(TRUNCATE)');
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Verify SQLite database integrity. Returns true if valid.
+ */
+export function verifyIntegrity(dbPath: string): boolean {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const result = db.pragma('integrity_check') as { integrity_check: string }[];
+    return result.length === 1 && result[0].integrity_check === 'ok';
+  } finally {
+    db.close();
+  }
+}
+
+interface BackupInfo {
+  filename: string;
+  timestamp: string;
+  size: number;
+  date: string;
+}
+
+/**
+ * GET /backup - List all backups
+ * Requires: admin permission
+ */
+router.get('/', requireWalletAuth, requireAdmin, async (_req: Request, res: Response) => {
+  try {
+    const backupsDir = getBackupsDir();
+    ensureBackupsDir();
+    const files = await readdir(backupsDir);
+    const backups: BackupInfo[] = [];
+
+    for (const file of files) {
+      if (file.startsWith('aurawallet.db.') && file.endsWith('.bak')) {
+        const filePath = join(backupsDir, file);
+        const fileStat = await stat(filePath);
+
+        // Extract timestamp from filename: aurawallet.db.YYYYMMDD_HHMMSS.bak
+        const match = file.match(/aurawallet\.db\.(\d{8}_\d{6})\.bak/);
+        const timestamp = match ? match[1] : '';
+
+        backups.push({
+          filename: file,
+          timestamp,
+          size: fileStat.size,
+          date: fileStat.mtime.toISOString(),
+        });
+      }
+    }
+
+    // Sort by date descending (newest first)
+    backups.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+
+    res.json({
+      success: true,
+      backups,
+    });
+  } catch (error) {
+    console.error('[Backup] Failed to list backups:', error);
+    res.status(500).json({ success: false, error: 'Failed to list backups' });
+  }
+});
+
+/**
+ * POST /backup - Create a new backup
+ * Requires: admin permission
+ */
+router.post('/', requireWalletAuth, requireAdmin, async (_req: Request, res: Response) => {
+  try {
+    const dbFile = getDbPath();
+    const backupsDir = getBackupsDir();
+    ensureBackupsDir();
+
+    // Check if database exists
+    if (!existsSync(dbFile)) {
+      res.status(404).json({ success: false, error: 'Database file not found' });
+      return;
+    }
+
+    // Generate timestamp
+    const now = new Date();
+    const timestamp = now.toISOString()
+      .replace(/[-:]/g, '')
+      .replace('T', '_')
+      .slice(0, 15);
+
+    const backupFilename = `aurawallet.db.${timestamp}.bak`;
+    const backupPath = join(backupsDir, backupFilename);
+    let credentialsCopied = 0;
+
+    // WAL checkpoint — flush all data to main DB file
+    walCheckpoint(dbFile);
+
+    // Atomic write: copy to temp file, then rename
+    const tempPath = backupPath + '.tmp';
+    await copyFile(dbFile, tempPath);
+    await rename(tempPath, backupPath);
+
+    // Verify backup integrity
+    if (!verifyIntegrity(backupPath)) {
+      await unlink(backupPath);
+      res.status(500).json({ success: false, error: 'Backup failed integrity check' });
+      return;
+    }
+
+    // Copy credential files alongside the DB backup.
+    if (existsSync(DATA_PATHS.credentials)) {
+      const credentialFiles = (await readdir(DATA_PATHS.credentials))
+        .filter(file => file.startsWith('cred-') && file.endsWith('.json'));
+
+      for (const file of credentialFiles) {
+        await copyFile(
+          join(DATA_PATHS.credentials, file),
+          join(backupsDir, `credentials.${timestamp}.${file}`),
+        );
+      }
+      credentialsCopied = credentialFiles.length;
+    }
+
+    // Clean up old backups (keep last 10)
+    const files = await readdir(backupsDir);
+    const backupFiles = files
+      .filter(f => f.startsWith('aurawallet.db.') && f.endsWith('.bak'))
+      .sort()
+      .reverse();
+
+    // Delete older backups beyond the 10th
+    for (let i = 10; i < backupFiles.length; i++) {
+      const oldBackup = backupFiles[i];
+      await unlink(join(backupsDir, oldBackup));
+
+      const match = oldBackup.match(/aurawallet\.db\.(\d{8}_\d{6})\.bak/);
+      if (!match) continue;
+
+      const oldTimestamp = match[1];
+      const oldCredentialFiles = files.filter(f => f.startsWith(`credentials.${oldTimestamp}.cred-`) && f.endsWith('.json'));
+      for (const oldCredentialFile of oldCredentialFiles) {
+        await unlink(join(backupsDir, oldCredentialFile));
+      }
+    }
+
+    const fileStat = await stat(backupPath);
+
+    logger.backup(backupFilename);
+
+    res.json({
+      success: true,
+      backup: {
+        filename: backupFilename,
+        timestamp,
+        size: fileStat.size,
+        date: fileStat.mtime.toISOString(),
+        credentialsCopied,
+      },
+    });
+  } catch (error) {
+    console.error('[Backup] Failed to create backup:', error);
+    res.status(500).json({ success: false, error: 'Failed to create backup' });
+  }
+});
+
+/**
+ * PUT /backup - Restore from a backup
+ * Requires: admin permission
+ *
+ * Hardened to match CLI restore: atomic write, pre-restore backup,
+ * integrity verification, schema migrations, and WAL cleanup.
+ */
+router.put('/', requireWalletAuth, requireAdmin, async (req: Request, res: Response) => {
+  try {
+    const { filename } = req.body;
+
+    if (!filename) {
+      res.status(400).json({ success: false, error: 'Filename is required' });
+      return;
+    }
+
+    // Validate filename format to prevent path traversal
+    if (!filename.match(/^aurawallet\.db\.\d{8}_\d{6}\.bak$/)) {
+      res.status(400).json({ success: false, error: 'Invalid backup filename' });
+      return;
+    }
+
+    const backupsDir = getBackupsDir();
+    const backupPath = join(backupsDir, filename);
+
+    if (!existsSync(backupPath)) {
+      res.status(404).json({ success: false, error: 'Backup file not found' });
+      return;
+    }
+
+    // Verify backup integrity before restoring
+    if (!verifyIntegrity(backupPath)) {
+      res.status(400).json({ success: false, error: 'Backup failed integrity check' });
+      return;
+    }
+
+    const dbPath = getDbPath();
+
+    // Create pre-restore safety backup
+    let preRestoreName = '';
+    if (existsSync(dbPath)) {
+      const now = new Date();
+      const ts = now.toISOString().replace(/[-:]/g, '').replace('T', '_').slice(0, 15);
+      preRestoreName = `pre-restore.${ts}.bak`;
+      await copyFile(dbPath, join(backupsDir, preRestoreName));
+    }
+
+    // Atomic write: copy to temp, then rename
+    const tempPath = dbPath + '.restore-tmp';
+    await copyFile(backupPath, tempPath);
+    await rename(tempPath, dbPath);
+
+    // Run schema migrations
+    try {
+      const { execSync } = await import('child_process');
+      execSync('npx prisma migrate deploy', {
+        cwd: join(dirname(dbPath), '..'),
+        env: { ...process.env, DATABASE_URL: `file:${dbPath}` },
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (migrationError: any) {
+      const errMsg = migrationError.stderr || migrationError.message || 'Unknown migration error';
+      logger.error(`[Backup] Migration failed after restore: ${errMsg}`);
+      // Restore the pre-restore backup since migration failed
+      if (preRestoreName && existsSync(join(backupsDir, preRestoreName))) {
+        const revertTemp = dbPath + '.revert-tmp';
+        await copyFile(join(backupsDir, preRestoreName), revertTemp);
+        await rename(revertTemp, dbPath);
+      }
+      res.status(500).json({
+        success: false,
+        error: `Restore aborted: schema migration failed. Pre-restore backup restored. Details: ${errMsg}`,
+      });
+      return;
+    }
+
+    // Verify restored DB integrity
+    if (!verifyIntegrity(dbPath)) {
+      logger.error('[Backup] Restored DB failed integrity check');
+      // Revert to pre-restore backup
+      if (preRestoreName && existsSync(join(backupsDir, preRestoreName))) {
+        const revertTemp = dbPath + '.revert-tmp';
+        await copyFile(join(backupsDir, preRestoreName), revertTemp);
+        await rename(revertTemp, dbPath);
+      }
+      res.status(500).json({
+        success: false,
+        error: 'Restored database failed integrity check. Pre-restore backup restored.',
+      });
+      return;
+    }
+
+    // Restore credential files from matching timestamp, if present.
+    const timestampMatch = filename.match(/aurawallet\.db\.(\d{8}_\d{6})\.bak$/);
+    let credentialsRestored = 0;
+    if (timestampMatch) {
+      const timestamp = timestampMatch[1];
+      const allBackupFiles = await readdir(backupsDir);
+      const credentialBackups = allBackupFiles
+        .filter(file => file.startsWith(`credentials.${timestamp}.cred-`) && file.endsWith('.json'));
+
+      if (credentialBackups.length > 0) {
+        if (!existsSync(DATA_PATHS.credentials)) {
+          mkdirSync(DATA_PATHS.credentials, { recursive: true });
+        }
+
+        const existingCredentialFiles = await readdir(DATA_PATHS.credentials);
+        for (const file of existingCredentialFiles) {
+          if (file.startsWith('cred-') && file.endsWith('.json')) {
+            await unlink(join(DATA_PATHS.credentials, file));
+          }
+        }
+
+        for (const backupFile of credentialBackups) {
+          const destName = backupFile.replace(`credentials.${timestamp}.`, '');
+          await copyFile(join(backupsDir, backupFile), join(DATA_PATHS.credentials, destName));
+        }
+        credentialsRestored = credentialBackups.length;
+      }
+    }
+
+    // Clean up old pre-restore backups (keep last 3)
+    const allFiles = await readdir(backupsDir);
+    const preRestoreFiles = allFiles
+      .filter(f => f.startsWith('pre-restore.') && f.endsWith('.bak'))
+      .sort()
+      .reverse();
+    for (let i = 3; i < preRestoreFiles.length; i++) {
+      await unlink(join(backupsDir, preRestoreFiles[i]));
+    }
+
+    res.json({
+      success: true,
+      message: 'Database restored successfully',
+      preRestoreBackup: preRestoreName,
+      credentialsRestored,
+    });
+  } catch (error) {
+    console.error('[Backup] Failed to restore backup:', error);
+    res.status(500).json({ success: false, error: 'Failed to restore backup' });
+  }
+});
+
+export default router;

package/server/routes/batch.ts

@@ -0,0 +1,270 @@
+/**
+ * POST /batch — Generic batch endpoint with dependency chaining.
+ *
+ * Dispatches sub-requests internally against the Express app.
+ * Auth is enforced per-sub-request via inherited headers.
+ */
+import { Router, Request, Response } from 'express';
+import http from 'http';
+import { Readable } from 'stream';
+import { Socket } from 'net';
+import {
+  validateBatchRequest,
+  resolveTemplates,
+  resolveBodyTemplates,
+  type BatchSubRequest,
+  type BatchResponse,
+} from '../lib/batch';
+
+const router = Router();
+
+const SUB_REQUEST_TIMEOUT_MS = 30_000;
+
+/**
+ * Dispatch a sub-request internally through the Express app.
+ * Creates mock req/res objects and calls app.handle().
+ */
+function dispatchInternal(
+  app: any,
+  method: string,
+  fullPath: string,
+  body: Record<string, unknown> | undefined,
+  parentReq: Request,
+): Promise<BatchResponse> {
+  return new Promise((resolve) => {
+    // Parse path and query string
+    const [pathname, queryString] = fullPath.split('?');
+    const query: Record<string, string> = {};
+    if (queryString) {
+      for (const pair of queryString.split('&')) {
+        const [key, ...rest] = pair.split('=');
+        query[decodeURIComponent(key)] = decodeURIComponent(rest.join('='));
+      }
+    }
+
+    // Build JSON body as a readable stream
+    const bodyStr = body ? JSON.stringify(body) : '';
+    const bodyBuf = Buffer.from(bodyStr);
+
+    // Create a mock IncomingMessage
+    const mockSocket = new Socket();
+    const req = new http.IncomingMessage(mockSocket);
+    req.method = method.toUpperCase();
+    req.url = fullPath;
+    (req as any).path = pathname;
+    (req as any).query = query;
+    (req as any).originalUrl = fullPath;
+
+    // Inherit auth headers from parent request
+    req.headers = {
+      'content-type': 'application/json',
+      host: parentReq.headers.host || 'localhost',
+    };
+    if (parentReq.headers.authorization) {
+      req.headers.authorization = parentReq.headers.authorization;
+    }
+
+    // Set content-length for body parsing
+    if (bodyStr) {
+      req.headers['content-length'] = String(bodyBuf.length);
+    }
+
+    // Push body data so express.json() can parse it
+    if (bodyBuf.length > 0) {
+      req.push(bodyBuf);
+    }
+    req.push(null); // EOF
+
+    // Create a mock ServerResponse that captures the output
+    const res = new http.ServerResponse(req);
+    let statusCode = 200;
+    let responseBody: unknown = null;
+    let resolved = false;
+
+    // Capture status
+    const origWriteHead = res.writeHead.bind(res);
+    res.writeHead = function (code: number, ...args: any[]) {
+      statusCode = code;
+      return origWriteHead(code, ...args);
+    } as any;
+
+    // Also capture statusCode set directly
+    Object.defineProperty(res, 'statusCode', {
+      get: () => statusCode,
+      set: (v: number) => { statusCode = v; },
+    });
+
+    // Intercept res.end() to capture the response body
+    const chunks: Buffer[] = [];
+    const origWrite = res.write.bind(res);
+    res.write = function (chunk: any, ...args: any[]) {
+      if (chunk) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+      return origWrite(chunk, ...args);
+    } as any;
+
+    const origEnd = res.end.bind(res);
+    res.end = function (chunk?: any, ...args: any[]) {
+      if (chunk) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+      if (!resolved) {
+        resolved = true;
+        const fullBody = Buffer.concat(chunks).toString('utf-8');
+        try {
+          responseBody = JSON.parse(fullBody);
+        } catch {
+          responseBody = fullBody || null;
+        }
+        resolve({ status: statusCode, body: responseBody });
+      }
+      return origEnd(chunk, ...args);
+    } as any;
+
+    // Also intercept json() if Express adds it (belt & suspenders)
+    (res as any).json = function (data: unknown) {
+      if (!resolved) {
+        resolved = true;
+        resolve({ status: statusCode, body: data });
+      }
+      // Still call the real json to ensure proper cleanup
+      const jsonStr = JSON.stringify(data);
+      res.setHeader('Content-Type', 'application/json');
+      origEnd(jsonStr);
+    };
+
+    // Timeout
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        resolve({ status: 504, body: { error: 'Sub-request timed out' } });
+        mockSocket.destroy();
+      }
+    }, SUB_REQUEST_TIMEOUT_MS);
+
+    // Clean up timer when resolved
+    const origResolve = resolve;
+    const wrappedResolve = (value: BatchResponse) => {
+      clearTimeout(timer);
+      origResolve(value);
+    };
+    // Patch: the resolve calls above already fire, so clear on end
+    res.on('finish', () => clearTimeout(timer));
+
+    // Dispatch through the Express app
+    app.handle(req, res);
+  });
+}
+
+// ── POST /batch ──
+
+router.post('/', async (req: Request, res: Response) => {
+  const { requests } = req.body || {};
+
+  // Validate
+  const validation = validateBatchRequest(requests);
+  if (!validation.valid) {
+    res.status(400).json({ success: false, error: validation.error });
+    return;
+  }
+
+  const { waves } = validation;
+  const requestMap = new Map<string, BatchSubRequest>();
+  for (const r of requests as BatchSubRequest[]) {
+    requestMap.set(r.id, r);
+  }
+
+  const responses = new Map<string, BatchResponse>();
+  const timings: Record<string, number> = {};
+
+  // Execute waves sequentially
+  for (const wave of waves) {
+    const wavePromises = wave.map(async (id) => {
+      const subReq = requestMap.get(id)!;
+      const start = Date.now();
+
+      // Check if dependency failed
+      if (subReq.dependsOn) {
+        const depResponse = responses.get(subReq.dependsOn);
+        if (depResponse && depResponse.status >= 400) {
+          const result: BatchResponse = {
+            status: 424,
+            body: { error: `Dependency "${subReq.dependsOn}" failed with status ${depResponse.status}` },
+          };
+          responses.set(id, result);
+          timings[id] = Date.now() - start;
+          return;
+        }
+      }
+
+      // Resolve templates in path
+      let resolvedPath: string;
+      try {
+        resolvedPath = resolveTemplates(subReq.path, responses);
+      } catch (err) {
+        const result: BatchResponse = {
+          status: 422,
+          body: { error: `Template resolution failed: ${(err as Error).message}` },
+        };
+        responses.set(id, result);
+        timings[id] = Date.now() - start;
+        return;
+      }
+
+      // Resolve templates in body
+      let resolvedBody: Record<string, unknown> | undefined;
+      if (subReq.body) {
+        try {
+          resolvedBody = resolveBodyTemplates(subReq.body, responses) as Record<string, unknown>;
+        } catch (err) {
+          const result: BatchResponse = {
+            status: 422,
+            body: { error: `Template resolution failed in body: ${(err as Error).message}` },
+          };
+          responses.set(id, result);
+          timings[id] = Date.now() - start;
+          return;
+        }
+      }
+
+      // Dispatch internally
+      const result = await dispatchInternal(
+        req.app,
+        subReq.method.toUpperCase(),
+        resolvedPath,
+        resolvedBody,
+        req,
+      );
+      responses.set(id, result);
+      timings[id] = Date.now() - start;
+    });
+
+    await Promise.all(wavePromises);
+  }
+
+  // Build response
+  const responseObj: Record<string, { status: number; body: unknown }> = {};
+  let succeeded = 0;
+  let failed = 0;
+  for (const [id, resp] of responses) {
+    responseObj[id] = { status: resp.status, body: resp.body };
+    if (resp.status < 400) {
+      succeeded++;
+    } else {
+      failed++;
+    }
+  }
+
+  res.json({
+    responses: responseObj,
+    meta: {
+      total: responses.size,
+      succeeded,
+      failed,
+      timings,
+    },
+  });
+});
+
+export default router;