` +
+ `Consulta la última sincronización de datos fácilmente desde ` +
+ `SCAIIWeb. ` +
+ `Inicia sesión y encontrarás esta información en la esquina inferior derecha de la pantalla.
`;
+
+/** Envuelve el contenido en el mismo cascarón del legacy (Arial, logo centrado, pie). */
+function renderSyncEmail(inner: string): string {
return `
-
-
-
-
-
-
-
-
- Alerta de respaldo — Aduanasoft
-
-
- ${alerts.length} base${alerts.length !== 1 ? 's' : ''} de datos sin restaurar recientemente
-
-
-
-
-
-
-
-
-
-
Base de datos
-
Cliente
-
Última restauración
-
Días sin sync
-
-
- ${rows}
-
-
-
-
-
-
-
- Este mensaje fue generado automáticamente por el Panel de Control de Bases de Datos Aduanasoft.
- Por favor no responda a este correo.
-
-
-
-
-
-
+
+
+
+
+
+ ${inner}
+ ${FOOTER}
+
`;
}
+/** Fecha en español "28 de junio de 2026, 17:26" (o "No disponible"), como el strftime del legacy. */
+export function formatFechaEs(iso: string | null | undefined): string {
+ if (!iso) return 'No disponible';
+ // Normaliza microsegundos (a24c manda isoformat con 6 dígitos) a milisegundos.
+ const cleaned = String(iso).replace(/(\.\d{3})\d+/, '$1');
+ const d = new Date(cleaned);
+ if (isNaN(d.getTime())) return 'No disponible';
+ const meses = [
+ 'enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio',
+ 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre'
+ ];
+ const dd = String(d.getDate()).padStart(2, '0');
+ const mm = meses[d.getMonth()];
+ const yyyy = d.getFullYear();
+ const HH = String(d.getHours()).padStart(2, '0');
+ const MM = String(d.getMinutes()).padStart(2, '0');
+ return `${dd} de ${mm} de ${yyyy}, ${HH}:${MM}`;
+}
+
+/** Correo de alerta de sincronización (kind=overdue), 1:1 con el legacy index.php. */
+export function buildBackupAlertHtml(alerts: BackupAlertRow[]): string {
+ const a = alerts[0];
+ const nombre = escHtml(a?.clientName ?? a?.visible_name ?? '');
+ const bd = escHtml(a?.visible_name ?? '');
+ const fecha = escHtml(formatFechaEs(a?.last_restore_date));
+ const inner = `
+
Notificación de Sincronización
+
Estimado ${nombre},
+
Detectamos que la base de datos ${bd} no se ha sincronizado correctamente en las últimas 24 horas.
+
La última restauración registrada fue: ${fecha}.
+ ${SCAIIWEB_H4}
+
Por favor, recuerde nunca cerrar la aplicación ni apagar su equipo. Revise la conexión e intente realizar una sincronización manual desde el botón Backup manual, o contacte al soporte técnico si es necesario.
`;
+ return renderSyncEmail(inner);
+}
+
+/** Correo de "sincronización restablecida" (kind=resolved): misma plantilla legacy, mensaje positivo. */
+export function buildBackupResolvedHtml(alerts: BackupAlertRow[]): string {
+ const a = alerts[0];
+ const nombre = escHtml(a?.clientName ?? a?.visible_name ?? '');
+ const bd = escHtml(a?.visible_name ?? '');
+ const fecha = escHtml(formatFechaEs(a?.last_restore_date));
+ const inner = `
+
Sincronización Restablecida
+
Estimado ${nombre},
+
La base de datos ${bd} volvió a sincronizarse correctamente.
+
La última restauración registrada fue: ${fecha}.
+ ${SCAIIWEB_H4}
+
No se requiere ninguna acción de su parte. Gracias por mantener su equipo y la aplicación en funcionamiento.
`;
+ return renderSyncEmail(inner);
+}
+
export interface BackupAlertRow {
visible_name: string;
clientName: string | null;
diff --git a/src/lib/server/restore-fetch.ts b/src/lib/server/restore-fetch.ts
new file mode 100644
index 0000000..a95a3d3
--- /dev/null
+++ b/src/lib/server/restore-fetch.ts
@@ -0,0 +1,103 @@
+/**
+ * Descarga de respaldos por restaurador, con ruta RELATIVA y SIN rutas fijas.
+ *
+ * La base de cada restaurador se DERIVA al vuelo de su Entrada reportada
+ * (`cloudrestore_status.input_folder`): hermana `Procesados`/`Fallados` (layout por defecto del
+ * install). El cliente solo envía `target` + `kind` + `relPath`; el servidor arma `base + relPath`
+ * y lo sirve leyendo la carpeta por filesystem (local o montada como share). CloudRestoreAS no
+ * reporta ni configura nada nuevo.
+ */
+import fs from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import { deriveSiblingFolder } from './backup-files';
+import { getRestoreTargetForDownload, type RestoreTargetDownload } from './controldesk-pg';
+
+export type BackupKind = 'procesados' | 'fallados';
+
+export class BackupDownloadError extends Error {
+ constructor(
+ public status: number,
+ message: string
+ ) {
+ super(message);
+ this.name = 'BackupDownloadError';
+ }
+}
+
+function baseSeparator(p: string): '\\' | '/' {
+ return p.includes('\\') ? '\\' : '/';
+}
+
+/** Carpeta base (procesados/fallados) del restaurador, SIEMPRE derivada de su Entrada. */
+function resolveBaseFolder(t: RestoreTargetDownload, kind: BackupKind): string | null {
+ const input = t.input_folder;
+ if (!input) return null;
+ return deriveSiblingFolder(input, kind === 'procesados' ? 'Procesados' : 'Fallados');
+}
+
+/** Valida la ruta relativa: sin '..', sin absoluto, sin componentes vacíos. */
+export function sanitizeRelPath(relPath: string): string | null {
+ const rel = String(relPath ?? '')
+ .replace(/\\/g, '/')
+ .trim();
+ if (!rel) return null;
+ if (rel.startsWith('/') || /^[a-zA-Z]:/.test(rel)) return null; // absoluto
+ const parts = rel.split('/');
+ if (parts.some((p) => p === '' || p === '.' || p === '..')) return null;
+ return parts.join('/');
+}
+
+function localJoin(base: string, rel: string): string {
+ const sep = baseSeparator(base);
+ const b = base.replace(/[\\/]+$/, '');
+ const relNative = rel.split('/').join(sep);
+ return `${b}${sep}${relNative}`;
+}
+
+export interface BackupDownload {
+ body: ReadableStream;
+ size: number | null;
+ filename: string;
+ cleanup: () => void;
+}
+
+/**
+ * Abre el stream de descarga de un respaldo desde la carpeta de procesados/fallados del
+ * restaurador (por filesystem). Lanza BackupDownloadError con el código HTTP apropiado.
+ */
+export async function openBackupDownload(
+ targetId: number,
+ kind: BackupKind,
+ relPathRaw: string
+): Promise {
+ const rel = sanitizeRelPath(relPathRaw);
+ if (!rel) throw new BackupDownloadError(400, 'Ruta de archivo inválida');
+
+ const target = await getRestoreTargetForDownload(targetId);
+ if (!target) throw new BackupDownloadError(404, 'Restaurador no encontrado');
+
+ const base = resolveBaseFolder(target, kind);
+ if (!base) throw new BackupDownloadError(409, 'El restaurador aún no reportó su carpeta de entrada');
+
+ const filename = rel.split('/').pop() as string;
+ const localPath = localJoin(base, rel);
+
+ let st;
+ try {
+ st = await fs.stat(localPath);
+ } catch {
+ throw new BackupDownloadError(404, 'Archivo de respaldo no encontrado o carpeta inaccesible');
+ }
+ if (!st.isFile()) {
+ throw new BackupDownloadError(404, 'La ruta indicada no es un archivo');
+ }
+
+ const node = createReadStream(localPath, { highWaterMark: 1024 * 1024 });
+ return {
+ body: Readable.toWeb(node) as unknown as ReadableStream,
+ size: st.size,
+ filename,
+ cleanup: () => node.destroy()
+ };
+}
diff --git a/src/lib/server/restore-inventory.ts b/src/lib/server/restore-inventory.ts
new file mode 100644
index 0000000..e9a2a07
--- /dev/null
+++ b/src/lib/server/restore-inventory.ts
@@ -0,0 +1,131 @@
+/**
+ * Escaneo del inventario de restauraciones LEYENDO las carpetas que usa CloudRestoreAS.
+ *
+ * Por cada restaurador toma la Entrada (`input_folder`) que ya reporta en `cloudrestore_status`,
+ * DERIVA sus hermanas `Procesados`/`Fallados` (deriveSiblingFolder) y las LEE por filesystem
+ * (listBackupFiles). Mapea cada archivo a su nodo (matchNodeRowFromBackupStem) y arma:
+ * - restaurados (de Procesados) → además hace upsert en `node_last_restore` (cache durable que
+ * preserva el "último respaldo por nodo" aunque se reasigne el restaurador o una carpeta quede
+ * temporalmente ilegible).
+ * - fallidos (de Fallados) → enriquecidos con `error_message` de `restore_job_logs` por filename.
+ *
+ * No requiere que CloudRestoreAS reporte nada nuevo: solo usa el `input_folder` ya reportado.
+ */
+import path from 'node:path';
+import { deriveSiblingFolder, listBackupFiles } from './backup-files';
+import {
+ listRestoreTargets,
+ listCloudRestoreStatuses,
+ listNodesForAssignment,
+ matchNodeRowFromBackupStem,
+ upsertNodeLastRestore,
+ listNodeLastRestore,
+ listFailedRestoreJobLogs,
+ type NodeLastRestoreRow
+} from './controldesk-pg';
+
+export interface FailedItem {
+ id: string; // clave estable para la UI: `${restore_target_id}:${rel_path}`
+ restore_target_id: number | null;
+ server_name: string | null;
+ node_key: string | null;
+ client_name: string | null;
+ db_name: string | null;
+ filename: string;
+ rel_path: string;
+ size_bytes: number;
+ error_message: string | null;
+ restored_at: Date;
+}
+
+export interface RestoreInventory {
+ restored: NodeLastRestoreRow[];
+ failed: FailedItem[];
+}
+
+const SCAN_OPTS = { maxDepth: 3, maxFiles: 5000 } as const;
+
+/** Escanea las carpetas de todos los restauradores y devuelve restaurados + fallidos. */
+export async function scanRestoreInventory(): Promise {
+ const [targets, statuses, nodes] = await Promise.all([
+ listRestoreTargets(),
+ listCloudRestoreStatuses(),
+ listNodesForAssignment()
+ ]);
+
+ // instance_key (case-insensitive) → input_folder reportado.
+ const inputByInstance = new Map();
+ for (const s of statuses) {
+ if (s.input_folder) inputByInstance.set(s.instance_key.trim().toLowerCase(), s.input_folder);
+ }
+
+ const failed: FailedItem[] = [];
+
+ for (const t of targets) {
+ const input = inputByInstance.get(String(t.name).trim().toLowerCase());
+ if (!input) continue; // este restaurador aún no reportó su Entrada
+
+ // Procesados → upsert del último respaldo por nodo.
+ try {
+ const procesados = deriveSiblingFolder(input, 'Procesados');
+ const { files } = await listBackupFiles(procesados, SCAN_OPTS);
+ for (const f of files) {
+ const match = matchNodeRowFromBackupStem(path.parse(f.name).name, nodes);
+ if (match && match.ID != null) {
+ await upsertNodeLastRestore({
+ databaseNodeId: Number(match.ID),
+ restoreTargetId: t.id,
+ dbName: (match.BDName as string) ?? null,
+ nodeKey: (match.NodoSubNodo as string) ?? null,
+ filename: f.name,
+ relPath: f.relPath,
+ sizeBytes: f.sizeBytes,
+ restoredAt: new Date(f.mtimeMs)
+ });
+ }
+ }
+ } catch {
+ /* Carpeta Procesados ilegible: se conserva lo cacheado en node_last_restore. */
+ }
+
+ // Fallados → lista viva (con enriquecimiento de error más abajo).
+ try {
+ const fallados = deriveSiblingFolder(input, 'Fallados');
+ const { files } = await listBackupFiles(fallados, SCAN_OPTS);
+ for (const f of files) {
+ const match = matchNodeRowFromBackupStem(path.parse(f.name).name, nodes);
+ failed.push({
+ id: `${t.id}:${f.relPath}`,
+ restore_target_id: t.id,
+ server_name: t.name,
+ node_key: (match?.NodoSubNodo as string) ?? null,
+ client_name: (match?.Nombre as string) ?? null,
+ db_name: (match?.BDName as string) ?? null,
+ filename: f.name,
+ rel_path: f.relPath,
+ size_bytes: f.sizeBytes,
+ error_message: null,
+ restored_at: new Date(f.mtimeMs)
+ });
+ }
+ } catch {
+ /* Carpeta Fallados ilegible: se omite este restaurador en fallidos. */
+ }
+ }
+
+ // Enriquecer fallidos con el error reportado (restore_job_logs) por filename.
+ try {
+ const logs = await listFailedRestoreJobLogs(500);
+ const errByFile = new Map();
+ for (const l of logs) errByFile.set(l.filename.trim().toLowerCase(), l.error_message);
+ for (const f of failed) {
+ f.error_message = errByFile.get(f.filename.trim().toLowerCase()) ?? null;
+ }
+ } catch {
+ /* sin bitácora: los fallidos se listan sin mensaje de error */
+ }
+
+ // Restaurados = estado durable por nodo (recién refrescado por el escaneo).
+ const restored = await listNodeLastRestore();
+ return { restored, failed };
+}
diff --git a/src/routes/+page.server.ts b/src/routes/+page.server.ts
index 3ccf7f0..76d0a2c 100644
--- a/src/routes/+page.server.ts
+++ b/src/routes/+page.server.ts
@@ -1,5 +1,4 @@
import { env } from '$env/dynamic/private';
-import fs from 'node:fs/promises';
import path from 'node:path';
import crypto from 'node:crypto';
import { redirect } from '@sveltejs/kit';
@@ -7,6 +6,9 @@ import type { PageServerLoad, Actions } from './$types';
import { verifyToken } from '$lib/server/auth';
import { getUserById, filterDatabasesByUserPermissions } from '$lib/server/users';
import { loadSqlDashboardFromNodes, type CatalogNodeRow } from '$lib/server/mssql-nodes';
+import { listBackupFiles } from '$lib/server/backup-files';
+import { scanRestoreInventory } from '$lib/server/restore-inventory';
+import { logger } from '$lib/server/logger';
import {
listClientsCatalog,
listDatabaseNodes,
@@ -22,7 +24,9 @@ import {
insertPortalUser,
updatePortalUser,
deletePortalUser,
- listRestoreTargets
+ listRestoreTargets,
+ listNodeLastRestore,
+ listFailedRestoreJobLogs
} from '$lib/server/controldesk-pg';
import {
listAdditionalEmails,
@@ -112,6 +116,8 @@ export const load: PageServerLoad = async ({ cookies }) => {
let summaryAZ: any = null;
let backupFiles: any[] = [];
+ let restoredBackups: any[] = [];
+ let failedRestores: any[] = [];
let clientsData: any[] = [];
let alertsData: any[] = [];
let basesDeDatosList: any[] = [];
@@ -187,54 +193,55 @@ export const load: PageServerLoad = async ({ cookies }) => {
// --- 4. Process Backups, Hydrate Alerts & Enriquecer databaseRows con datos de BasesDeDatos ---
try {
- let files: string[] = [];
- try {
- files = await fs.readdir(env.BACKUP_PATH as string);
- } catch (e) {
- files = [];
- errors.backups = "No se pudo acceder a la carpeta de respaldos.";
- }
-
- for (const file of files) {
- if (file === '.' || file === '..') continue;
-
- const filePath = path.join(env.BACKUP_PATH as string, file);
- let stats;
+ // El CloudRestoreAS nuevo reubica los respaldos en `Procesados//`; se
+ // recorre la raíz de forma recursiva (ver listBackupFiles). BACKUP_PATH debe apuntar
+ // a esa raíz. Las entradas ya vienen ordenadas por fecha descendente y con multipart
+ // colapsado.
+ const backupRoot = env.BACKUP_PATH as string | undefined;
+ if (!backupRoot) {
+ errors.backups = 'La ruta de respaldos (BACKUP_PATH) no está configurada.';
+ } else {
+ let listing: { files: Awaited>['files']; truncated: boolean };
try {
- stats = await fs.stat(filePath);
- } catch { continue; }
-
- if (!stats.isFile()) continue;
-
- const nodoName = path.parse(file).name;
- let clientData: any = null;
-
- if (controlDeskOk && basesDeDatosList.length) {
- try {
- clientData = matchNodeRowFromBackupStem(nodoName, basesDeDatosList);
- } catch {
- /* ignore */
- }
+ listing = await listBackupFiles(backupRoot);
+ } catch {
+ listing = { files: [], truncated: false };
+ errors.backups = 'No se pudo acceder a la carpeta de respaldos.';
}
- backupFiles.push({
- name: file,
- nodo_name: (clientData?.NodoSubNodo as string | undefined) || nodoName,
- client_name: clientData?.Nombre ?? 'Cliente no identificado',
- client_authority: clientData?.RFC ?? 'N/A',
- bd_shelter: 'N/A',
- date: stats.mtime,
- size: (stats.size / 1024 / 1024).toFixed(2) + " MB"
- });
+ if (listing.truncated) {
+ logger.warn({
+ message: 'Listado de respaldos recortado por límite de archivos',
+ context: { backupRoot }
+ });
+ }
+
+ for (const entry of listing.files) {
+ const nodoName = path.parse(entry.name).name;
+ let clientData: any = null;
+
+ if (controlDeskOk && basesDeDatosList.length) {
+ try {
+ clientData = matchNodeRowFromBackupStem(nodoName, basesDeDatosList);
+ } catch {
+ /* ignore */
+ }
+ }
+
+ backupFiles.push({
+ name: entry.name,
+ relPath: entry.relPath,
+ parts: entry.parts,
+ nodo_name: (clientData?.NodoSubNodo as string | undefined) || nodoName,
+ client_name: clientData?.Nombre ?? 'Cliente no identificado',
+ client_authority: clientData?.RFC ?? 'N/A',
+ bd_shelter: 'N/A',
+ date: new Date(entry.mtimeMs),
+ size: (entry.sizeBytes / 1024 / 1024).toFixed(2) + ' MB'
+ });
+ }
}
- // Ordenar respaldos de más reciente a más antiguo por fecha de modificación
- backupFiles.sort((a, b) => {
- const da = new Date(a.date).getTime();
- const db = new Date(b.date).getTime();
- return db - da;
- });
-
if (controlDeskOk && alertsData.length > 0) {
alertsData = await Promise.all(
alertsData.map(async (alert) => {
@@ -293,6 +300,28 @@ export const load: PageServerLoad = async ({ cookies }) => {
console.error("Error processing backups/alerts hydration:", e);
}
+ // Inventario "respaldos restaurados por nodo" (sobrevive a reasignación) y "restores
+ // fallidos", desde la BD (poblados vía job-result). Tolerante a fallos: si falla, se
+ // muestran vacíos sin romper el dashboard.
+ try {
+ // Escanea las carpetas Procesados/Fallados (derivadas de la Entrada reportada por cada
+ // restaurador) y refresca el cache node_last_restore. Refleja la realidad en cada carga.
+ const inv = await scanRestoreInventory();
+ restoredBackups = inv.restored;
+ failedRestores = inv.failed;
+ } catch (e: any) {
+ console.error('Error escaneando inventario de restauraciones:', e);
+ // Fallback al cache/BD si el escaneo falla por completo (p.ej. sin acceso a carpetas).
+ try {
+ [restoredBackups, failedRestores] = await Promise.all([
+ listNodeLastRestore(),
+ listFailedRestoreJobLogs(200)
+ ]);
+ } catch (e2: any) {
+ console.error('Fallback de inventario de restauraciones también falló:', e2);
+ }
+ }
+
// CALCULAR MÉTRICAS DE RESTAURACIÓN basadas en last_restore_date (ANTES del filtro)
restoredCount = 0;
notRestoredCount = 0;
@@ -357,6 +386,8 @@ export const load: PageServerLoad = async ({ cookies }) => {
summaryAZ,
backupFiles,
+ restoredBackups,
+ failedRestores,
clientsData,
alertsData,
basesDeDatosList,
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 4e97b22..b69aaf3 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -2,7 +2,7 @@
import { untrack, tick } from 'svelte';
import { deserialize } from '$app/forms';
import { invalidateAll, goto } from '$app/navigation';
- import aduanasoftLogo from '$lib/assets/logo.png';
+ import AppShell from '$lib/components/AppShell.svelte';
type KitActionPayload = { success?: boolean; message?: string };
@@ -42,6 +42,10 @@
const restoredCount = $derived(data.restoredCount);
const notRestoredCount = $derived(data.notRestoredCount);
const backupFiles = $derived(data.backupFiles);
+ const restoredBackups = $derived(data.restoredBackups ?? []);
+ const failedRestores = $derived(data.failedRestores ?? []);
+ const formatMb = (bytes: number | null | undefined) =>
+ bytes == null ? '—' : (Number(bytes) / 1024 / 1024).toFixed(2) + ' MB';
const clientsData = $derived(data.clientsData);
const alertsData = $derived(data.alertsData);
const basesDeDatosList = $derived(data.basesDeDatosList);
@@ -74,7 +78,9 @@
})());
// Estado de vista activa y paginación
- let activeView = $state<'dashboard' | 'backups' | 'clients' | 'alerts' | 'databases'>('dashboard');
+ let activeView = $state<
+ 'dashboard' | 'backups' | 'restored' | 'failed' | 'clients' | 'alerts' | 'databases'
+ >('dashboard');
// Persistencia de la vista activa del sidebar en localStorage
const ACTIVE_VIEW_KEY = 'aduanasoft-dashboard-active-view';
@@ -86,6 +92,8 @@
if (
stored === 'dashboard' ||
stored === 'backups' ||
+ stored === 'restored' ||
+ stored === 'failed' ||
stored === 'clients' ||
stored === 'alerts' ||
stored === 'databases'
@@ -333,23 +341,6 @@
});
};
- // Estado del sidebar colapsado
- let sidebarCollapsed = $state(false);
-
- // Persistir estado del sidebar
- if (typeof window !== 'undefined') {
- const storedCollapsed = window.localStorage.getItem('sidebar-collapsed');
- if (storedCollapsed) {
- sidebarCollapsed = storedCollapsed === 'true';
- }
- }
-
- const toggleSidebar = () => {
- sidebarCollapsed = !sidebarCollapsed;
- if (typeof window !== 'undefined') {
- window.localStorage.setItem('sidebar-collapsed', String(sidebarCollapsed));
- }
- };
// Auto-refresh del panel principal (cada 40 segundos)
if (typeof window !== 'undefined') {
@@ -1120,250 +1111,70 @@
};
-
- Configura IP, credenciales y rutas de cada servidor. La asignación de cada base a
- un servidor se hace en Gestión de Bases de Datos (un radio por base).
+ Configura IP, credenciales, rutas y capacidad de cada servidor, y asigna qué bases
+ restaura cada uno (checklist o distribución automática por capacidad).
@@ -118,79 +707,355 @@
{/if}
{#if form?.success}
-
+
Operación realizada correctamente.
{/if}
+ {#if successMsg}
+
+ check_circle
+ {successMsg}
+
+ {/if}
{#if data.dbWarning}
{data.dbWarning}
{/if}
+
-
CloudRestoreAS por servidor
-
- Cada servidor de restauración puede tener su propia instalación de CloudRestoreAS.
- La carpeta de entrada se configura en cada equipo; el panel solo la muestra.
-
+
Servidores
{#if targets.length === 0}
Crea un servidor con + Nuevo servidor.
{:else}
-
- {#each targets as t (t.id)}
- {@const cra = statusForTarget(t.name)}
-
+