feat : ajout download backup

server/api/backups.get.ts

@@ -0,0 +1,156 @@
+import { execFile } from "node:child_process"
+
+const REMOTE_HOST = process.env.BACKUPS_REMOTE_HOST || "malio-b@192.168.0.179"
+const REMOTE_ROOT = process.env.BACKUPS_REMOTE_ROOT || "/home/malio-b/backups"
+const MAX_FILES_PER_FOLDER = Number(process.env.BACKUPS_MAX_FILES || "200")
+const isSafeFolder = (value: string) => /^[a-zA-Z0-9._-]+$/.test(value)
+const shellQuote = (value: string) => `'${value.replace(/'/g, `'\\''`)}'`
+const FOLDER_MAP: Record<string, string> = {
+  ferme: "bdd_recette/ferme",
+  inventory: "bdd_recette/inventory",
+  sirh: "bdd_recette/sirh",
+  user: "bdd_recette/user",
+  bitwarden: "bitwarden"
+}
+
+function runSsh(command: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "ssh",
+      ["-o", "BatchMode=yes", "-o", "ConnectTimeout=5", REMOTE_HOST, command],
+      { maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(stderr || error.message)
+          return
+        }
+        resolve(stdout)
+      }
+    )
+  })
+}
+
+function isMissingPathError(error: unknown): boolean {
+  const message = String(error || "").toLowerCase()
+  return message.includes("no such file or directory") || message.includes("cannot access")
+}
+
+function toServerError(error: unknown) {
+  return createError({
+    statusCode: 500,
+    statusMessage: `Erreur SSH backups: ${String(error)}`
+  })
+}
+
+function parseLines(output: string): string[] {
+  return output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+}
+
+function quoteDir(pathValue: string) {
+  return shellQuote(pathValue)
+}
+
+async function listRemoteFiles(remoteDir: string): Promise<string[]> {
+  const output = await runSsh(
+    `cd ${quoteDir(remoteDir)} && ls -1A | sort -r | head -n ${MAX_FILES_PER_FOLDER}`
+  )
+  return parseLines(output)
+}
+
+async function listRemoteDirs(remoteRoot: string): Promise<string[]> {
+  const output = await runSsh(
+    `cd ${quoteDir(remoteRoot)} && for d in */; do [ -d "$d" ] && printf '%s\n' "\${d%/}"; done`
+  )
+  return parseLines(output)
+}
+
+async function getLatestRemoteFile(remoteDir: string): Promise<string | null> {
+  const output = await runSsh(
+    `cd ${quoteDir(remoteDir)} && ls -1A | sort -r | head -n 1`
+  )
+  const files = parseLines(output)
+  return files[0] || null
+}
+
+async function remoteDirExists(remoteDir: string): Promise<boolean> {
+  const output = await runSsh(`[ -d ${quoteDir(remoteDir)} ] && echo yes || echo no`)
+  return output.trim() === "yes"
+}
+
+async function resolveFolderRemoteDir(folderName: string): Promise<string | null> {
+  const mapped = FOLDER_MAP[folderName]
+  if (mapped) {
+    return `${REMOTE_ROOT}/${mapped}`
+  }
+
+  const direct = `${REMOTE_ROOT}/${folderName}`
+  if (await remoteDirExists(direct)) {
+    return direct
+  }
+
+  const nested = `${REMOTE_ROOT}/bdd_recette/${folderName}`
+  if (await remoteDirExists(nested)) {
+    return nested
+  }
+
+  return null
+}
+
+export default defineEventHandler(async (event) => {
+  const { folder } = getQuery(event)
+  const folderName = typeof folder === "string" ? folder : null
+
+  // Si un dossier est demandé, on retourne sa liste de fichiers.
+  if (folderName) {
+    if (!isSafeFolder(folderName)) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Paramètre folder invalide"
+      })
+    }
+
+    const remoteDir = await resolveFolderRemoteDir(folderName)
+    if (!remoteDir) return []
+
+    try {
+      return await listRemoteFiles(remoteDir)
+    } catch (error) {
+      if (isMissingPathError(error)) return []
+      throw toServerError(error)
+    }
+  }
+
+  // Sinon on récupère le dernier backup de chaque dossier distant.
+  let dirs: string[] = []
+  try {
+    dirs = await listRemoteDirs(REMOTE_ROOT)
+  } catch (error) {
+    throw toServerError(error)
+  }
+
+  const result: Array<{ folder: string; last: string | null }> = []
+
+  for (const dirName of dirs) {
+    const remoteDir = `${REMOTE_ROOT}/${dirName}`
+    try {
+      result.push({
+        folder: dirName,
+        last: await getLatestRemoteFile(remoteDir)
+      })
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        result.push({
+          folder: dirName,
+          last: null
+        })
+        continue
+      }
+      throw toServerError(error)
+    }
+  }
+
+  return result
+})

server/api/discord/messages.get.ts

@@ -0,0 +1,15 @@
+export default defineEventHandler(async () => {
+    const token = process.env.DISCORD_BOT_TOKEN
+    const channel = process.env.DISCORD_CHANNEL_ID
+
+    const messages = await $fetch(
+        `https://discord.com/api/v10/channels/${channel}/messages?limit=20`,
+        {
+            headers: {
+                Authorization: `Bot ${token}`
+            }
+        }
+    )
+
+    return messages
+})

server/api/download.get.ts

@@ -1,25 +1,136 @@
+import { execFile, spawn } from "node:child_process"
 import { Readable } from "node:stream"
 
-export default defineEventHandler((event) => {
-    const size = 128 * 1024 * 1024
-    let sent = 0
+const REMOTE_HOST = process.env.BACKUPS_REMOTE_HOST || "malio-b@192.168.0.179"
+const REMOTE_ROOT = process.env.BACKUPS_REMOTE_ROOT || "/home/malio-b/backups"
+const FOLDER_MAP: Record<string, string> = {
+  ferme: "bdd_recette/ferme",
+  inventory: "bdd_recette/inventory",
+  sirh: "bdd_recette/sirh",
+  user: "bdd_recette/user",
+  bitwarden: "bitwarden"
+}
 
-    const stream = new Readable({
-        read(chunkSize) {
-            if (sent >= size) {
-                this.push(null)
-                return
-            }
+const isSafeFolder = (value: string) => /^[a-zA-Z0-9._-]+$/.test(value)
+const isSafeFile = (value: string) => /^[^/\\]+$/.test(value)
+const shellQuote = (value: string) => `'${value.replace(/'/g, `'\\''`)}'`
 
-            const remaining = size - sent
-            const chunk = Buffer.alloc(Math.min(chunkSize, remaining), "a")
-            sent += chunk.length
-            this.push(chunk)
+function runSsh(command: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "ssh",
+      ["-o", "BatchMode=yes", "-o", "ConnectTimeout=5", REMOTE_HOST, command],
+      { maxBuffer: 5 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(stderr || error.message)
+          return
         }
-    })
+        resolve(stdout)
+      }
+    )
+  })
+}
 
-    setHeader(event, "Content-Type", "application/octet-stream")
-    setHeader(event, "Content-Length", size)
+async function remoteDirExists(remoteDir: string): Promise<boolean> {
+  const output = await runSsh(`[ -d ${shellQuote(remoteDir)} ] && echo yes || echo no`)
+  return output.trim() === "yes"
+}
 
-    return stream
-})
+async function resolveFolderRemoteDir(folderName: string): Promise<string | null> {
+  const mapped = FOLDER_MAP[folderName]
+  if (mapped) {
+    return `${REMOTE_ROOT}/${mapped}`
+  }
+
+  const direct = `${REMOTE_ROOT}/${folderName}`
+  if (await remoteDirExists(direct)) {
+    return direct
+  }
+
+  const nested = `${REMOTE_ROOT}/bdd_recette/${folderName}`
+  if (await remoteDirExists(nested)) {
+    return nested
+  }
+
+  return null
+}
+
+function buildContentDisposition(fileName: string) {
+  const asciiName = fileName.replace(/[^\x20-\x7E]/g, "_").replace(/["\\]/g, "_")
+  return `attachment; filename="${asciiName}"; filename*=UTF-8''${encodeURIComponent(fileName)}`
+}
+
+function speedtestStream(event: any) {
+  const size = 128 * 1024 * 1024
+  let sent = 0
+
+  const stream = new Readable({
+    read(chunkSize) {
+      if (sent >= size) {
+        this.push(null)
+        return
+      }
+
+      const remaining = size - sent
+      const chunk = Buffer.alloc(Math.min(chunkSize, remaining), "a")
+      sent += chunk.length
+      this.push(chunk)
+    }
+  })
+
+  setHeader(event, "Content-Type", "application/octet-stream")
+  setHeader(event, "Content-Length", size)
+  return stream
+}
+
+export default defineEventHandler(async (event) => {
+  const { folder, file } = getQuery(event)
+  const folderName = typeof folder === "string" ? folder : null
+  const fileName = typeof file === "string" ? file : null
+
+  // Compat mode: utilisé par le test de débit.
+  if (!folderName || !fileName) {
+    return speedtestStream(event)
+  }
+
+  if (!isSafeFolder(folderName) || !isSafeFile(fileName)) {
+    throw createError({ statusCode: 400, statusMessage: "Paramètres invalides" })
+  }
+
+  const remoteDir = await resolveFolderRemoteDir(folderName)
+  if (!remoteDir) {
+    throw createError({ statusCode: 404, statusMessage: "Dossier introuvable" })
+  }
+
+  const remotePath = `${remoteDir}/${fileName}`
+  const existsOutput = await runSsh(`[ -f ${shellQuote(remotePath)} ] && echo yes || echo no`)
+  if (existsOutput.trim() !== "yes") {
+    throw createError({ statusCode: 404, statusMessage: "Fichier introuvable" })
+  }
+
+  setHeader(event, "Content-Type", "application/octet-stream")
+  setHeader(event, "Content-Disposition", buildContentDisposition(fileName))
+
+  const child = spawn("ssh", [
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "ConnectTimeout=5",
+    REMOTE_HOST,
+    `cat ${shellQuote(remotePath)}`
+  ])
+
+  let stderr = ""
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString()
+  })
+
+  child.on("close", (code) => {
+    if (code !== 0) {
+      console.error(`Erreur téléchargement SSH (${code}): ${stderr}`)
+    }
+  })
+
+  return sendStream(event, child.stdout)
+})