chore: remove agent-oriented comments from the codebase (#25)
CD — Deployment / deploy (push) Successful in 23s

PR automatique de chore/code-cleanup vers main.

---------

Co-authored-by: xEsiah <[email protected]>
Reviewed-on: #25
Reviewed-by: Esiah <[email protected]>
Co-authored-by: Gitea Actions <-[email protected]>
This commit was merged in pull request #25.
This commit is contained in:
Gitea Actions
2026-11-04 15:04:00 +00:00
committed by Esiah
co-authored by Esiah
parent fb7d0bab16
commit d837817bcb
52 changed files with 70 additions and 841 deletions
-40
View File
@@ -1,22 +1,6 @@
import type { Context } from "hono";
import { clientIp as sharedClientIp, type Db, type SessionUser } from "./lib/index.js";
/**
* Les droits sont toujours recalcules depuis la session serveur. Le role de
* l'utilisateur ne vient jamais d'un en-tete client : une requete qui se
* declare admin n'a aucun effet sur cette evaluation.
*
* Le role `admin` ne donne aucun droit special sur les dossiers ni sur les
* fichiers : un administrateur n'accede qu'a ses propres dossiers et a ceux
* partages nominativement avec lui, exactement comme un compte ordinaire. Son
* role ne sert qu'au panneau d'administration. Consequence directe : il n'est
* membre que des salons de discussion des dossiers auxquels il a acces.
*/
/**
* SQL de lecture repetee : proprietaire, permission nominative non expiree, ou
* dossier public (accessible a tout compte authentifie).
*/
export const READ_SQL = `( f.owner_id = ?
OR f.access_type = 'public'
OR EXISTS ( SELECT 1 FROM folder_permissions fp
@@ -58,11 +42,6 @@ export const canRead = async (db: Db, user: SessionUser, folderId: string): Prom
return row !== null;
};
/**
* Ecriture explicite : proprietaire du dossier, ou permission nominative
* `write`/`admin`. Un dossier public en est exclu : il autorise le depot, mais
* pas la modification ni la suppression des fichiers d'autrui.
*/
export const canWriteExplicit = async (
db: Db,
user: SessionUser,
@@ -83,11 +62,6 @@ export const canWriteExplicit = async (
return row !== null;
};
/**
* Gestion du dossier (renommer, deplacer, supprimer, regler les permissions,
* moderer le salon) : reservee au proprietaire. Un dossier public permet
* d'ajouter, pas de reorganiser l'espace commun.
*/
export const canManageFolder = async (
db: Db,
user: SessionUser,
@@ -101,19 +75,11 @@ export const canManageFolder = async (
return row !== null;
};
/**
* Verifie si l'utilisateur peut traverser un dossier pour atteindre un
* sous-dossier auquel il a acces. Un dossier est traversable s'il y a un
* acces direct OU s'il existe un descendant non supprime ayant un acces
* direct valide (proprietaire, permission nominative, ou descendant public).
* Cela n'accorde PAS d'acces au contenu des dossiers intermediaires.
*/
export const canTraverse = async (
db: Db,
user: SessionUser,
folderId: string,
): Promise<boolean> => {
// Acces direct au dossier
const direct = await db.one(
`SELECT 1 AS granted
FROM folders f
@@ -129,7 +95,6 @@ export const canTraverse = async (
);
if (direct !== null) return true;
// Verifie s'il existe un descendant avec acces direct valide
const descendant = await db.one(
`WITH RECURSIVE descendants AS (
SELECT id, parent_id FROM folders WHERE parent_id = ? AND deleted_at IS NULL
@@ -156,11 +121,6 @@ export const canTraverse = async (
const clientIp = (context: Context, trustProxy: boolean): string | null =>
sharedClientIp(context, trustProxy);
/**
* Journalise une action sensible. audit_logs survit a la suppression du compte
* (ON DELETE SET NULL) avec un instantane de l'e-mail : c'est la seule trace
* qui reste une fois l'utilisateur efface.
*/
export const audit = async (
db: Db,
context: Context,
-14
View File
@@ -2,19 +2,6 @@
import { randomUUID } from "node:crypto";
import { ConfigError, loadDbConfig, hashPassword, AppError, toSafeError } from "./lib/index.js";
/**
* Creation et reinitialisation des comptes, en dehors de toute requete HTTP.
*
* Cette commande ne lit que les variables DB : elle doit pouvoir creer le
* premier administrateur alors que l'API n'a pas encore le droit de demarrer.
*
* node dist/admin.js --email [email protected] --first Jean --last Dupont [--role admin]
* node dist/admin.js --email [email protected] --reset
*
* Mot de passe : ADMIN_PASSWORD dans l'environnement, sinon --password,
* sinon un mot de passe aleatoire est genere et affiche une seule fois.
*/
const USAGE = `Utilisation : cohaise-admin --email <adr> --first <prenom> --last <nom> [options]
--email <adr> Adresse du compte (obligatoire)
@@ -59,7 +46,6 @@ const parseArgs = (argv: string[]): Args => {
return args;
};
/** Mot de passe aleatoire, lisible a la frappe, sans caractere ambigu. */
const generatePassword = (): string => {
const alphabet = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789";
const bytes = new Uint8Array(18);
-12
View File
@@ -7,18 +7,6 @@ import { Db } from "./lib/db.js";
import { AppError, toSafeError } from "./lib/errors.js";
import { listMigrations, runMigrations } from "./lib/migrate.js";
/**
* Point d'entree des migrations : `node dist/cli.js --dir <dossier>`.
*
* Le conteneur de migration n'a besoin d'aucun secret lisible a la main :
* les variables sont resolues par Docker depuis .env au lancement.
*
* Codes de sortie :
* 0 tout est applique, ou rien a faire
* 1 erreur (connexion, SQL, migration) OU derive detectee
* 2 configuration incomplete
*/
interface Options {
dir: string;
dryRun: boolean;
-10
View File
@@ -13,9 +13,6 @@ import { registerSearchRoutes } from "./routes/search.js";
import { registerTrashRoutes, purgeExpiredTrash } from "./routes/trash.js";
import { purgeExpiredUploads, registerUploadRoutes } from "./routes/uploads.js";
// Les migrations sont relues au demarrage. L'operation est idempotente et
// refuse de servir si une migration deja appliquee a change : une base non
// migree rend donc l'API inaccessible plutot que de renvoyer des erreurs 500.
const migrationsDir = join(dirname(fileURLToPath(import.meta.url)), "../migrations");
void startService({
@@ -35,24 +32,17 @@ void startService({
registerAdminRoutes(app, db, config);
},
onReady: async ({ db, config, logger }) => {
// Entretien au demarrage : sessions expirees et corbeille hors retention.
const sessions = await purgeExpiredSessions(db);
const purged = await purgeExpiredTrash(db, config);
const uploads = await purgeExpiredUploads(db, config);
logger.info("entretien au demarrage", { sessions, purged, uploads });
// Les envois abandonnes ne doivent pas garder leur temporaire indefiniment :
// un balayage horaire suffit, la session expirant apres 24 h.
setInterval(() => {
void purgeExpiredUploads(db, config).catch((error: unknown) =>
logger.error("purge des envois inacheves", { error: String(error) }),
);
}, 60 * 60 * 1000).unref();
// Sessions expirees et corbeille hors retention : sans ce balayage, elles
// ne disparaissent qu'au redemarrage. Les jetons expires sont deja refuses
// a chaque requete ; il s'agit ici d'eviter une table qui grossit sans fin
// et de faire respecter la retention de la corbeille sans redemarrage.
setInterval(() => {
void purgeExpiredSessions(db).catch((error: unknown) =>
logger.error("purge des sessions expirees", { error: String(error) }),
-46
View File
@@ -19,12 +19,6 @@ const scrypt = promisify(scryptCallback) as (
options: { N: number; r: number; p: number; maxmem?: number },
) => Promise<Buffer>;
/**
* scrypt du module natif, pas une dependance externe. Une lib native a compiler
* est la facon la plus rapide de casser un build sur une machine cible : argon2
* ou bcrypt produisent un binaire qui n'est pas portable sans outilchain.
* node:crypto est deja la, et scrypt est un KDF defini par RFC 7914.
*/
const SCRYPT = { N: 16384, r: 8, p: 1, keylen: 64, maxmem: 32 * 1024 * 1024 };
export const hashPassword = async (password: string): Promise<string> => {
@@ -55,24 +49,9 @@ export const verifyPassword = async (password: string, stored: string): Promise<
export const sha256 = (value: string): string => createHash("sha256").update(value).digest("hex");
/**
* Empreinte du jeton de session : SHA-256 poivre par SESSION_SECRET.
*
* Sans ce poivre, une ecriture frauduleuse dans `user_sessions` suffirait a
* forger une session : l'attaquant connaitrait le hachage a poser. Le secret
* vit hors de la base, donc une fuite de la base seule ne donne aucune session
* ouvrable.
*/
export const sessionTokenHash = (token: string, secret: string): string =>
createHmac("sha256", secret).update(token).digest("hex");
/**
* Portrait de l'utilisateur porte par la session.
*
* Les budgets de stockage n'y figurent pas : une valeur figee dans un cookie
* serait fausse des la premiere ecriture. Chaque route qui en a besoin relit
* les colonnes en base au moment de l'usage.
*/
export interface SessionUser {
id: string;
email: string;
@@ -91,12 +70,6 @@ export interface SessionMeta {
export const SESSION_COOKIE = "cohaise_session";
/**
* Le jeton brut part dans le cookie, son empreinte HMAC-SHA-256 (poivree par
* SESSION_SECRET) dans la base. Une copie de la base ne donne donc aucune
* session ouvrable : il faudrait en plus la table des cookies, qui n'existe pas,
* et le secret, qui vit hors de la base.
*/
export const createSession = async (
db: Db,
userId: string,
@@ -143,7 +116,6 @@ export const resolveSession = async (
[sessionTokenHash(token, secret)],
);
if (!row) return null;
// Etat vu, avec un decalage de 60 s pour ne pas ecrire a chaque requete.
await db.exec(
"UPDATE user_sessions SET last_seen_at = UTC_TIMESTAMP() WHERE token_hash = ? AND last_seen_at < UTC_TIMESTAMP(3) - INTERVAL 60 SECOND",
[sessionTokenHash(token, secret)],
@@ -162,17 +134,6 @@ export const purgeExpiredSessions = async (db: Db): Promise<number> => {
return result.affectedRows;
};
/**
* Secure depend du schema reel de la requete, pas d'une origine configuree.
*
* Deriver Secure de PUBLIC_ORIGIN rendait tout test local impossible : le
* navigateur rejette en HTTP un cookie marque Secure, donc la connexion
* echouait sans message exploitable. A l'inverse, un cookie non Secure servi en
* HTTPS laisserait le jeton circuler en clair.
*
* X-Forwarded-Proto n'est pris en compte que si le service fait confiance a son
* proxy ; sinon la connexion parle d'elle-meme.
*/
export const isHttpsRequest = (context: Context, trustProxy: boolean): boolean => {
if (trustProxy) {
const forwarded = context.req.header("x-forwarded-proto");
@@ -205,7 +166,6 @@ export interface AuthState {
token: string;
}
/** Lit le cookie et attache l'utilisateur, sans exiger qu'il existe. */
export const attachUser =
(db: Db, secret: string) =>
async (context: Context, next: Next): Promise<void> => {
@@ -222,11 +182,6 @@ export const attachUser =
await next();
};
/**
* Routes encore accessibles lorsqu'un changement de mot de passe est impose :
* lire son profil, changer le mot de passe, se deconnecter. Tout le reste est
* refuse cote serveur, et pas seulement par la redirection du client.
*/
const PASSWORD_CHANGE_ALLOWED = new Set([
"/api/cloud/auth/me",
"/api/cloud/auth/change-password",
@@ -242,7 +197,6 @@ export const requireAuth = async (context: Context, next: Next): Promise<void> =
await next();
};
/** Le role est impose en base, jamais en entete, donc ni cacheable ni falsifiable. */
export const requireRole =
(...slugs: string[]) =>
async (context: Context, next: Next): Promise<void> => {
-19
View File
@@ -1,13 +1,5 @@
import { z } from "zod";
/**
* Configuration lue une seule fois au demarrage. L'objet est fige :
* si une variable manque ou est mal formee, le processus s'arrete avant
* d'ouvrir le moindre port, avec la liste exacte de ce qui pose probleme.
* Une API qui demarre puis echoue sur la premiere requete est un defaut de
* deploiement, pas un defaut d'ecriture de code.
*/
const bool = (fallback: boolean) =>
z
.string()
@@ -28,7 +20,6 @@ const schema = z.object({
LOG_LEVEL: z.enum(["silent", "error", "warn", "info", "debug"]).default("info"),
PORT: port(3000),
/** Origine publique absolue, indispensable aux liens envoyes par courriel. */
PUBLIC_ORIGIN: z.url(),
DB_HOST: z.string().min(1),
@@ -49,26 +40,17 @@ const schema = z.object({
TRUST_PROXY: bool(false),
CORS_ORIGIN: z.string().optional().transform((v) => v ?? null),
// Envoi de courriel : obligatoire, l'application refuse de demarrer sans,
// car la reinitialisation de mot de passe et le changement d'adresse en
// dependent. Un relais local sans authentification reste possible : seuls
// l'hote et l'expediteur sont exiges.
SMTP_HOST: z.string().min(1),
SMTP_PORT: port(587),
SMTP_USER: z.string().optional().transform((v) => (v ? v : null)),
SMTP_PASSWORD: z.string().optional().transform((v) => (v ? v : null)),
SMTP_FROM: z.string().min(3),
SMTP_SECURE: bool(false),
/**
* Logo des courriels. Par defaut le logo embarque (`backend/src/assets/logo.png`,
* joint au message) ; renseigner une URL pour forcer une image distante.
*/
MAIL_LOGO_URL: z
.string()
.optional()
.transform((v) => (v ? v : null)),
// Limitation des tentatives de connexion, appliquee dans le processus.
RATE_LIMIT_LOGIN_MAX: positiveInt(10),
RATE_LIMIT_LOGIN_WINDOW_MS: positiveInt(60_000),
});
@@ -90,7 +72,6 @@ export const loadConfig = (env: NodeJS.ProcessEnv = process.env): Config => {
return Object.freeze(parsed.data);
};
/** Sous-ensemble DB, pour les outils qui n'ouvrent aucun port (migrations, CLI). */
const dbSchema = z.object({
NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
LOG_LEVEL: z.enum(["silent", "error", "warn", "info", "debug"]).default("info"),
-8
View File
@@ -23,22 +23,16 @@ export class Db {
timezone: "Z",
charset: "utf8mb4_unicode_ci",
decimalNumbers: true,
// Porte refermee sur les requetes empilees : sans cet option, une
// contamination d'une lecture echappait en INSERT ou en DROP. Les valeurs
// sont toujours transmises en parametres, jamais concatenees dans le SQL.
multipleStatements: false,
namedPlaceholders: false,
});
}
/** Lecture en protocole prepare : les valeurs sont binaires, jamais des chains de texte. */
async query<T = RowDataPacket>(sql: string, params: unknown[] = []): Promise<T[]> {
const [rows] = await this.pool.execute(sql, params as never);
return rows as T[];
}
/** Requete brute, sans parametres, reservee au DDL des migrations.
Certains etats DDL ne passent pas le protocole prepare de MariaDB. */
async raw(sql: string): Promise<void> {
await this.pool.query(sql);
}
@@ -48,7 +42,6 @@ export class Db {
return (rows[0] as T | undefined) ?? null;
}
/** Le premier resultat, ou une erreur explicite plutot qu'un undefined silencieux. */
async required<T = RowDataPacket>(sql: string, params: unknown[] = []): Promise<T> {
const row = await this.one<T>(sql, params);
if (row === null) {
@@ -77,7 +70,6 @@ export class Db {
}
}
/** Forme courte des erreurs de contrainte, pour les repondre en 409 et non en 500. */
static classify(error: unknown): { status: number; message: string } {
const errno = (error as { errno?: number })?.errno;
const sqlMessage = (error as { sqlMessage?: string })?.sqlMessage ?? "";
-7
View File
@@ -1,9 +1,3 @@
/**
* Erreurs portees par un code HTTP. Une erreur qui n'en porte pas est
* consideree interne : on journalise le detail, on ne le rend jamais au
* client, parce que le message d'une exception ne doit pas decrire le schema.
*/
export class AppError extends Error {
readonly status: number;
readonly code: string;
@@ -66,7 +60,6 @@ export const toSafeError = (error: unknown): SafeError => {
return { status, code: code ?? "BAD_REQUEST", message: (error as Error).message };
}
// Une erreur MariaDB connue est un probleme d'exploitation, pas un crash.
const errno = (error as { errno?: number })?.errno;
if (errno !== undefined) {
const { status: dbStatus, message } = classifyDbError(errno);
-22
View File
@@ -45,23 +45,16 @@ export const createLogger = (level: Config["LOG_LEVEL"], service: string): Logge
};
};
/** Variables transportees par chaque requete : tracee d'identification. */
export interface AppEnv {
Variables: {
requestId: string;
/** Posee par attachUser quand le cookie de session est valide. */
user?: SessionUser;
token?: string;
};
}
/** Type public d'une application CoHaiSe, impose aux routes metier. */
export type App = Hono<AppEnv>;
/**
* IP reelle de l'appelant : X-Forwarded-For n'est cru que si le service fait
* confiance a son proxy. La valeur est tronquee a la taille de la colonne.
*/
export const clientIp = (context: Context, trustProxy: boolean): string | null => {
if (trustProxy) {
const forwarded = context.req.header("x-forwarded-for");
@@ -75,15 +68,8 @@ export const clientIp = (context: Context, trustProxy: boolean): string | null =
return address ? address.slice(0, 45) : null;
};
/** Taille maximale d'un corps JSON. Les envois de fichiers ont leur propre flux borne. */
export const JSON_BODY_MAX_BYTES = 1024 * 1024;
/**
* Lit le corps de la requete en memoire, avec une borne dure sur les octets
* reellement recus. `content-length` est verifie d'abord pour refuser tot, mais
* la lecture bornee est la vraie garantie : un client peut mentir sur l'en-tete
* et envoyer davantage que ce qu'il annonce.
*/
export const readBodyCapped = async (context: Context, maxBytes: number): Promise<Buffer> => {
const declared = Number(context.req.header("content-length") ?? "");
if (Number.isFinite(declared) && declared > maxBytes) {
@@ -113,11 +99,6 @@ export const readBodyCapped = async (context: Context, maxBytes: number): Promis
return Buffer.concat(chunks);
};
/**
* Parse le corps JSON avec la meme borne. Un corps absent ou illisible rend
* `null`, comme l'ancien `req.json().catch(() => null)` : les routes continuent
* de repondre par leur validation zod habituelle.
*/
export const readJson = async (
context: Context,
maxBytes = JSON_BODY_MAX_BYTES,
@@ -131,7 +112,6 @@ export const readJson = async (
}
};
/** Dependances remises aux routes metier au montage. */
export interface RouteDeps {
db: Db;
config: Config;
@@ -143,9 +123,7 @@ export interface AppOptions {
config: Config;
db: Db;
logger: Logger;
/** Routes metier, montees sous /api/<service> dans le routing. */
routes: (app: App, deps: RouteDeps) => void;
/** Vrai quand l'API doit repondre a /healthz avec l'etat de la base. */
probeDb?: boolean;
}
-14
View File
@@ -1,25 +1,13 @@
import type { Config } from "./config.js";
/**
* Gabarit de courriel de marque, sans dependance ni feuille de style externe :
* les clients de messagerie n'interpretent qu'une partie du CSS, tout est donc
* ecrit en ligne et pose sur des tableaux, y compris pour Outlook.
*/
export interface Branding {
appName: string;
origin: string;
logoUrl: string;
color: string;
/** Adresse d'expedition, reprise en pied pour dire ou ne pas repondre. */
footer: string;
}
/**
* Identifiant de la piece jointe du logo. Le logo est embarque dans le message
* (voir `mail.ts`) : l'image s'affiche meme si le client bloque les ressources
* distantes. `MAIL_LOGO_URL` force une image distante a la place.
*/
export const LOGO_CID = "cohaise-logo";
export const branding = (config: Config): Branding => ({
@@ -31,12 +19,10 @@ export const branding = (config: Config): Branding => ({
});
export interface MailContent {
/** Aperçu affiche par le client, avant ouverture (texte brut). */
preview: string;
heading: string;
intro: string;
paragraphs?: string[];
/** Identifiants d'acces, presentes dans un encadre monospace. */
credentials?: { email: string; password: string };
cta?: { label: string; url: string };
note?: string;
-16
View File
@@ -3,18 +3,6 @@ import { createTransport, type Transporter } from "nodemailer";
import type { Config } from "./config.js";
import { LOGO_CID } from "./mail-template.js";
/**
* Envoi de courriel via SMTP.
*
* Le transport est construit une seule fois au demarrage. L'application exige
* les variables SMTP_* : sans elles, elle refuse de demarrer plutot que de
* laisser une reinitialisation de mot de passe silencieusement sans effet.
*/
/**
* Logo embarque dans les messages. Le chemin remonte depuis `src/lib` ou
* `dist/lib` vers `backend/src/assets/logo.png`, present dans l'image.
*/
const LOGO_PATH = new URL("../../src/assets/logo.png", import.meta.url);
const loadLogo = (): Buffer | null => {
@@ -29,7 +17,6 @@ export interface MailMessage {
to: string;
subject: string;
text: string;
/** Version enrichie ; les clients texte recoivent `text`, les autres `html`. */
html?: string;
}
@@ -49,8 +36,6 @@ export const createMailer = (config: Config): Mailer => {
disableUrlAccess: true,
});
// Logo embarque une seule fois. `MAIL_LOGO_URL` le remplace par une image
// distante : dans ce cas on n'attache rien.
const logo = config.MAIL_LOGO_URL ? null : loadLogo();
return {
@@ -70,6 +55,5 @@ export const createMailer = (config: Config): Mailer => {
};
};
/** Lien absolu construit sur PUBLIC_ORIGIN, qui est valide au demarrage. */
export const link = (config: Config, path: string): string =>
new URL(path, config.PUBLIC_ORIGIN).toString();
-24
View File
@@ -3,18 +3,6 @@ import { readdir, readFile } from "node:fs/promises";
import path from "node:path";
import type { Db } from "./db.js";
/**
* Applique les fichiers NNN_nom.sql dans l'ordre lexical, et uniquement ceux
* qui ne sont pas encore marques comme appliques. Idempotent : un second appel
* ne reexecute rien.
*
* Limite connue et assumee : le DDL MariaDB n'est pas transactionnel. Un fichier
* echoue au milieu, le reste des statements n'est pas applique et le fichier
* n'est pas enregistre. Le repasser reprend depuis son debut. C'est pourquoi
* chaque migration part de la ou la precedente a fini, et pourquoi une migration
* en desordre doit etre reparue et pas seulement sauvegardee depuis sa moitie.
*/
export interface MigrationFile {
version: string;
file: string;
@@ -25,12 +13,9 @@ export interface MigrationFile {
export interface MigrationResult {
applied: string[];
skipped: string[];
/** Migrations deja appliquees dont le contenu du fichier a change depuis. */
drifted: { version: string; recorded: string; current: string }[];
}
// Les deux bases utilisent un prefixe a trois chiffres (000, 001, …) ;
// quatre est accepte pour ne pas interdire le passage a un dossier plus large.
const FILE_PATTERN = /^(\d{3,4}_[a-z0-9_]+)\.sql$/;
export const listMigrations = async (dir: string): Promise<MigrationFile[]> => {
@@ -58,8 +43,6 @@ const ensureLedger = async (db: Db): Promise<void> => {
PRIMARY KEY (version)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
`);
// Creer la colonne ici plutot que dans une migration : ajouter une ligne a un
// registre qui enregistre lui-meme les lignes ajoutees boucle sur lui-meme.
await db.raw(
"ALTER TABLE schema_migrations ADD COLUMN IF NOT EXISTS checksum CHAR(64) NULL AFTER applied_at",
);
@@ -101,13 +84,6 @@ export const runMigrations = async (
continue;
}
// Un statement par un statement : un filet de faille reste visible et le
// point d'arret reste reproductible plutot qu'un bloc de 400 lignes perdu.
//
// Les lignes de commentaire sont retirees, pas le statement entier : un
// en-tete de fichier ou une legende au-dessus d'un INSERT ne doit pas
// faire sauter la requete, et encore moins la faire sauter en silence
// pendant que la version est enregistree comme appliquee.
const statements = migration.sql
.split(/;\s*(?:\r?\n|$)/)
.map((statement) =>
-17
View File
@@ -1,23 +1,9 @@
/**
* Limiteur de debit en memoire.
*
* Volontairement minimal : une seule instance d'API, donc un simple compteur
* glissant par cle suffit. La protection robuste contre une attaque repartie
* vit dans nginx (`limit_req`) ; celle-ci couvre le cas ou l'API est jointe
* directement, sans proxy.
*
* La memoire est bornee : les entrees purgees a chaque appel ne s'accumulent
* pas, et une entree dont toutes les tentatives sont sorties de la fenetre est
* oubliee.
*/
interface Bucket {
count: number;
resetAt: number;
}
export interface RateLimiter {
/** Vrai quand la tentative est permise ; faux une fois la borne atteinte. */
allow: (key: string) => boolean;
}
@@ -33,8 +19,6 @@ export const createRateLimiter = (max: number, windowMs: number): RateLimiter =>
return {
allow: (key) => {
const now = Date.now();
// Purge a chaque appel : le cout est proportionnel au nombre de cles
// actives, borne par la fenetre, jamais par l'historique complet.
prune(now);
const bucket = buckets.get(key);
if (!bucket || bucket.resetAt <= now) {
@@ -48,5 +32,4 @@ export const createRateLimiter = (max: number, windowMs: number): RateLimiter =>
};
};
/** Identifiant de limitation : IP reelle si le proxy est de confiance, sinon socket. */
export const rateLimitKey = (ip: string | null): string => ip ?? "unknown";
-14
View File
@@ -16,14 +16,9 @@ import { assertNoDrift, runMigrations } from "./migrate.js";
export interface ServiceOptions {
service: string;
/** Dossier contenant les fichiers NNN_nom.sql de cette application. */
migrationsDir?: string;
routes: (app: App, deps: RouteDeps) => void;
probeDb?: boolean;
/**
* Tache d'entretien executee une fois la base joignable et migree, avant
* l'ouverture du port (purge des sessions ou de la corbeille).
*/
onReady?: (deps: RouteDeps) => Promise<void> | void;
}
@@ -52,10 +47,6 @@ const fail = (error: unknown): never => {
process.exit(1);
};
/**
* Prepare le service sans lancer d'ecoute. Utile pour la CLI de migration et
* pour les tests, qui n'ont pas besoin d'un port.
*/
export const prepareService = async (options: ServiceOptions): Promise<Service> => {
const config = loadConfig();
const logger = createLogger(config.LOG_LEVEL, options.service);
@@ -78,8 +69,6 @@ export const prepareService = async (options: ServiceOptions): Promise<Service>
try {
await options.onReady({ db, config, logger });
} catch (error) {
// L'entretien ne doit jamais empecher de servir : une purge en echec est
// signalee, la base reste exploitable.
logger.error("tache de demarrage en echec", {
error: error instanceof Error ? error.message : String(error),
});
@@ -98,7 +87,6 @@ export const prepareService = async (options: ServiceOptions): Promise<Service>
return { config, db, logger, app };
};
/** Demarre, ecoute, et s'arrete proprement. */
export const startService = async (options: ServiceOptions): Promise<Server> => {
let prepared: Service;
try {
@@ -115,8 +103,6 @@ export const startService = async (options: ServiceOptions): Promise<Server> =>
const shutdown = async (signal: string) => {
logger.info("arret demande", { signal });
// Le SIGTERM de docker stop a un delai limite : fermer d'abord l'ecoute
// evite de nouvelles requetes, puis attendre les requetes en cours.
server.close(async () => {
await db.close().catch((error: unknown) => logger.error("fermeture base", { error: String(error) }));
logger.info("arret termine");
-23
View File
@@ -5,14 +5,6 @@ import sharp from "sharp";
import type { Config, Db } from "./lib/index.js";
import { absolutePath } from "./storage.js";
/**
* Traitement des images : vignette et metadonnees.
*
* sharp charge une bibliotheque native ; les images sont decodees en flux et
* la vignette est ecrite en WebP, format nettement plus compact que le JPEG
* d'origine pour un rendu equivalent dans une grille.
*/
export type MediaKind = "image" | "video" | "audio" | "document" | "archive" | "other";
const THUMBNAIL_PX = 480;
@@ -48,12 +40,6 @@ export const classify = (mime: string | null): MediaKind => {
export const isImage = (mime: string | null): boolean =>
(mime ?? "").toLowerCase().startsWith("image/");
/**
* Le SVG est une image au sens MIME, mais pas une image sure a decoder :
* librsvg peut resolvere des references externes et son moteur est une surface
* d'attaque supplementaire. Il est deja exclu de l'apercu en ligne ; on ne le
* passe pas non plus a sharp pour la vignette. Le fichier reste telechargeable.
*/
const isRasterImage = (mime: string | null): boolean => {
const value = (mime ?? "").toLowerCase();
return value.startsWith("image/") && value !== "image/svg+xml";
@@ -93,14 +79,6 @@ const writeThumbnail = async (source: string, destination: string): Promise<Thum
return { width: info.width, height: info.height, size: info.size };
};
/**
* Indexe un fichier qui vient d'etre ecrit. Les insertions sont idempotentes
* (ON DUPLICATE KEY) : un fichier deja indexe est simplement remis a jour.
*
* Un echec ici ne doit jamais faire echouer le depot lui-meme : le fichier est
* deja publie et payable, seule la vignette manquerait. L'appelant ignore donc
* l'erreur.
*/
export const indexMedia = async (
db: Db,
config: Config,
@@ -141,7 +119,6 @@ export const indexMedia = async (
);
};
/** Taille d'une vignette deja ecrite, ou null si le fichier a disparu. */
export const thumbnailSize = async (config: Config, relative: string): Promise<number | null> => {
try {
const info = await stat(absolutePath(config.VARIANT_DIR, relative));
-2
View File
@@ -285,8 +285,6 @@ export const registerAccountRoutes = (app: App, db: Db, config: Config): void =>
[data.email],
);
// Reponse identique que le compte existe ou non : rien ne permet de
// decouvrir une adresse enregistree.
if (user) {
const token = newToken();
await db.exec(
-34
View File
@@ -103,7 +103,6 @@ const SELECT_USER = `
const UNITS = ["o", "Ko", "Mo", "Go", "To", "Po"];
/** Taille lisible, pour les messages d'erreur destines a l'administrateur. */
const humanBytes = (bytes: number): string => {
let value = bytes;
let unit = 0;
@@ -114,27 +113,13 @@ const humanBytes = (bytes: number): string => {
return `${value.toFixed(unit === 0 || value >= 10 ? 0 : 1)} ${UNITS[unit]}`;
};
/** Mot de passe aleatoire, lisible a la frappe, sans caractere ambigu. */
const generatePasswordValue = (): string => {
const alphabet = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789";
// randomInt borne directement l'intervalle : pas de biais modulo, contrairement
// a `octet % longueur` qui favorise les premiers caracteres de l'alphabet.
let out = "";
for (let index = 0; index < 18; index += 1) out += alphabet[randomInt(alphabet.length)];
return out;
};
/**
* Reprise des dossiers d'un compte supprime. Un dossier partage (permission
* nominative active vers un autre compte actif) survit avec un nouveau
* proprietaire : le meilleur candidat par niveau (admin puis write puis read),
* le plus ancien en cas d'egalite. Un dossier sans partage disparait avec son
* sous-arbre, a la maniere de `DELETE /folders/:id`. Un enfant partage dont le
* parent disparait remonte a la racine ; il en va de meme pour les dossiers
* d'autres comptes instales sous un dossier supprime, qui ne doivent pas
* devenir orphelins. Les permissions detenues par le compte supprime sur les
* dossiers d'autrui sont retirees.
*/
const rehomeUserFolders = async (db: Db, userId: string): Promise<{ kept: number; deleted: number }> => {
const folders = await db.query<{ id: string; parent_id: string | null }>(
"SELECT id, parent_id FROM folders WHERE owner_id = ? AND deleted_at IS NULL AND is_system = 0",
@@ -145,7 +130,6 @@ const rehomeUserFolders = async (db: Db, userId: string): Promise<{ kept: number
const ids = folders.map((folder) => folder.id);
const placeholders = ids.map(() => "?").join(",");
// Meilleur candidat par dossier : permission non expiree vers un compte actif.
const candidates = await db.query<{
folder_id: string;
user_id: string;
@@ -173,7 +157,6 @@ const rehomeUserFolders = async (db: Db, userId: string): Promise<{ kept: number
await db.transaction(async (connection) => {
for (const [id, owner] of newOwner) {
const parentId = owned.get(id) ?? null;
// Parent supprime avec le compte : l'enfant partage remonte a la racine.
const parentGone = parentId !== null && owned.has(parentId) && !newOwner.has(parentId);
await connection.execute(
"UPDATE folders SET owner_id = ?, parent_id = ? WHERE id = ?",
@@ -183,7 +166,6 @@ const rehomeUserFolders = async (db: Db, userId: string): Promise<{ kept: number
if (deleteIds.length > 0) {
const delPh = deleteIds.map(() => "?").join(",");
// Dossiers d'autres comptes installes sous un dossier supprime : a la racine.
await connection.execute(
`UPDATE folders SET parent_id = NULL
WHERE parent_id IN (${delPh}) AND deleted_at IS NULL
@@ -200,7 +182,6 @@ const rehomeUserFolders = async (db: Db, userId: string): Promise<{ kept: number
);
}
// Permissions du compte supprime sur les dossiers d'autrui.
await connection.execute("DELETE FROM folder_permissions WHERE user_id = ?", [userId]);
await connection.execute("DELETE FROM user_file_stars WHERE user_id = ?", [userId]);
});
@@ -218,12 +199,6 @@ export const registerAdminRoutes = (app: App, db: Db, config: Config): void => {
if (currentUser(context).role_slug !== "admin") throw AppError.forbidden();
};
/**
* Un quota ne peut depasser la capacite reelle du disque qui porte les
* medias : au-dela, la limite est un chiffre mort que le support ne pourra
* jamais honorer. Le controle est ignore si le support n'est pas lisible
* (chemin absent dans le conteneur), pour ne pas bloquer la configuration.
*/
const assertQuotaFits = async (quota: number): Promise<void> => {
const disk = await diskUsage(config.MEDIA_DIR);
if (disk !== null && quota > disk.total_bytes) {
@@ -403,8 +378,6 @@ export const registerAdminRoutes = (app: App, db: Db, config: Config): void => {
);
if (result.affectedRows === 0) throw AppError.notFound("Compte introuvable.");
// Avant la reprise : les dossiers partages trouvent un nouveau proprietaire,
// les autres disparaissent avec leur sous-arbre.
const rehomed = await rehomeUserFolders(db, id);
await db.exec("UPDATE user_sessions SET revoked_at = UTC_TIMESTAMP() WHERE user_id = ?", [id]);
@@ -433,8 +406,6 @@ export const registerAdminRoutes = (app: App, db: Db, config: Config): void => {
[id],
);
// Le mot de passe est envoye au compte ; la reponse ne le contient pas.
// Un echec d'envoi n'invalide pas la reinitialisation.
const mail = renderMail(brand, {
preview: "Un nouveau mot de passe a ete genere pour votre compte.",
heading: "Mot de passe reinitialise",
@@ -523,11 +494,6 @@ export const registerAdminRoutes = (app: App, db: Db, config: Config): void => {
return context.json({ ok: true });
});
/**
* Facettes du journal : valeurs distinctes utilisees pour alimenter les
* listes deroulantes de filtre (actions et comptes ayant agi). Un compte
* supprime reste identifiable par son e-mail conserve dans le journal.
*/
app.get("/api/cloud/admin/audit/filters", requireAuth, async (context) => {
requireAdmin(context);
const actions = await db.query<{ action: string }>(
-22
View File
@@ -26,11 +26,6 @@ const credentials = z.object({
password: z.string().min(1).max(1024),
});
/**
* Hachage de repli, calcule paresseusement a la premiere echec de connexion.
* Sans lui, un compte inexistant repond plus vite qu'un compte existant, ce qui
* permet d'enumerer les adresses e-mail en mesurant le temps de reponse.
*/
let dummyHash: Promise<string> | undefined;
const decoyHash = (): Promise<string> => (dummyHash ??= hashPassword("aucun-compte-ne-correspond"));
@@ -80,9 +75,6 @@ const SELECT_USER = `
LEFT JOIN user_avatars ua ON ua.user_id = u.id`;
export const registerAuthRoutes = (app: App, db: Db, config: Config): void => {
// Aucune reponse de l'API ne doit etre mise en cache. Sans en-tete explicite,
// les navigateurs appliquent un cache heuristique et reservent une liste de
// fichiers obsolete apres une suppression ou un depot.
app.use("/api/cloud/*", async (context, next) => {
await next();
context.header("cache-control", "no-store");
@@ -92,8 +84,6 @@ export const registerAuthRoutes = (app: App, db: Db, config: Config): void => {
const limiter = createRateLimiter(config.RATE_LIMIT_LOGIN_MAX, config.RATE_LIMIT_LOGIN_WINDOW_MS);
app.post("/api/cloud/auth/login", async (context) => {
// Borne les tentatives par IP : une attaque par dictionnaire sur un mot de
// passe faible est arretee avant le calcul scrypt, couteux.
const ip = clientIp(context, config.TRUST_PROXY);
if (!limiter.allow(rateLimitKey(ip))) {
throw AppError.unprocessable("Trop de tentatives de connexion. Reessayez dans une minute.");
@@ -105,8 +95,6 @@ export const registerAuthRoutes = (app: App, db: Db, config: Config): void => {
const { email, password } = parsed.data;
const row = await db.one<UserRow>(`${SELECT_USER} WHERE u.active_email = ?`, [email]);
// Meme travail dans les deux cas, pour que le temps de reponse ne
// revele pas si l'adresse existe.
const stored = row && row.is_active === 1 ? row.password_hash : await decoyHash();
if (!row || row.is_active !== 1 || !(await verifyPassword(password, stored))) {
throw AppError.unauthorized("Identifiants invalides.");
@@ -125,10 +113,6 @@ export const registerAuthRoutes = (app: App, db: Db, config: Config): void => {
);
await db.exec("UPDATE users SET last_login_at = UTC_TIMESTAMP() WHERE id = ?", [row.id]);
// Le marqueur Secure suit le protocole reellement annonce, pas
// NODE_ENV : un deploiement en HTTP local doit rester utilisable, un
// deploiement https:// ne doit jamais poser de cookie cleartext.
// Le schema reel de la requete, pas PUBLIC_ORIGIN : voir isHttpsRequest.
const secure = isHttpsRequest(context, config.TRUST_PROXY);
setSessionCookie(context, token, expiresAt, secure);
@@ -154,11 +138,6 @@ export const registerAuthRoutes = (app: App, db: Db, config: Config): void => {
next: z.string().min(8).max(1024),
});
/**
* Changement impose a la premiere connexion. Les autres sessions sont
* revoquees : si le compte avait ete ouvert ailleurs, l'ancien mot de passe
* ne doit plus rien ouvrir.
*/
app.post("/api/cloud/auth/change-password", requireAuth, async (context) => {
const session = currentUser(context);
const parsed = changePassword.safeParse(await readJson(context));
@@ -186,7 +165,6 @@ export const registerAuthRoutes = (app: App, db: Db, config: Config): void => {
WHERE id = ?`,
[hash, session.id],
);
// La session courante est conservee, toutes les autres sont revoquees.
await db.exec(
`UPDATE user_sessions
SET revoked_at = UTC_TIMESTAMP()
-68
View File
@@ -11,15 +11,6 @@ import {
} from "../lib/index.js";
import { audit, canManageFolder, canRead, READ_SQL } from "../access.js";
/**
* Chat attache a un dossier. Le salon ne se lit et ne s'ecrit qu'avec l'acces
* au dossier : le role global ne suffit jamais, `admin` compris.
*
* Les membres du salon sont exactement les comptes qui ont acces au dossier
* (proprietaire, permissions nominatives, dossier public). Un administrateur
* n'est donc membre que des salons des dossiers partages avec lui.
*/
const uuid = z
.string()
.regex(
@@ -31,12 +22,10 @@ const sendInput = z.object({
body: z.string().trim().min(1, "Message vide.").max(2000, "Message trop long."),
});
/** Meme borne que l'envoi : un message edite ne peut pas devenir plus long. */
const editInput = z.object({
body: z.string().trim().min(1, "Message vide.").max(2000, "Message trop long."),
});
/** Horodatage renvoye tel quel par le serveur : `AAAA-MM-JJTHH:MM:SS.ffffff`. */
const DATETIME_CURSOR = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,6})?$/;
interface MessageRow {
@@ -51,7 +40,6 @@ interface MessageRow {
avatar_updated_at: Date | null;
}
/** Auteur joint a la ligne : meme jointure que la lecture, pour la reponse du POST. */
const SELECT_MESSAGE = `
SELECT m.id, m.user_id, m.body, m.created_at, m.edited_at, m.is_pinned,
u.first_name, u.last_name, ua.updated_at AS avatar_updated_at
@@ -73,14 +61,8 @@ const publicMessage = (row: MessageRow) => ({
});
export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
// Ecriture bornee par compte : le salon reste utilisable meme si un client
// s'emballe. La lecture (interrogation periodique) n'est pas limitee ici.
const limiter = createRateLimiter(20, 10_000);
/**
* Le dossier doit exister et etre accessible : `canRead` rejette une session
* sans acces comme un dossier inexistant (404, pour ne rien confirmer).
*/
const assertFolder = async (
folderId: string,
): Promise<{ id: string; owner_id: string | null; access_type: string }> => {
@@ -93,7 +75,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
return folder;
};
/** Reprise du curseur de lecture du salon pour la session courante. */
const markRead = async (folderId: string, userId: string, messageId: number): Promise<void> => {
if (messageId <= 0) return;
await db
@@ -108,11 +89,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
.catch(() => undefined);
};
/**
* Pastilles de messages non lus : tous les salons accessibles a la session
* qui contiennent au moins un message qu'elle n'a pas encore lu. Les
* messages de la session ignores : il n'a rien de neuf a lire.
*/
app.get("/api/cloud/chat/unread", requireAuth, async (context) => {
const user = currentUser(context);
const rows = await db.query<{ folder_id: string; unread: number }>(
@@ -144,9 +120,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
const folder = await assertFolder(folderId);
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
// Les membres sont ceux qui ont acces au dossier : proprietaire,
// permission nominative non expiree, et tous les comptes actifs si le
// dossier est public. Le role global ne compte pas.
const rows = await db.query<{
id: string;
first_name: string;
@@ -194,20 +167,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
const limit = Math.min(200, Math.max(1, Number(context.req.query("limit")) || 50));
const after = Math.max(0, Number(context.req.query("after")) || 0);
/**
* Curseur d'edition. Le curseur `after` ne voit que les messages plus
* recents : une reecriture d'un ancien message y resterait invisible.
*
* Le curseur est un horodatage de la base, dans le meme cadran que la
* colonne `edited_at` : le client le renvoie tel quel, sans conversion.
* Comparer une chaine ISO (UTC) a un DATETIME stocke en heure locale
* decalerait la fenetre de la difference de fuseau.
*
* Il est calcule AVANT la requete : une edition survenue entre les deux
* porte un horodatage posterieur au curseur, elle sera donc vue au tour
* suivant plutot que perdue.
*/
// `cursor` est un mot reserve en MariaDB : l'alias est renomme.
const cursorRow = await db.one<{ chat_cursor: string }>(
"SELECT DATE_FORMAT(CURRENT_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f') AS chat_cursor",
);
@@ -218,9 +177,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
? editedAfterRaw
: serverCursor;
// `after` sert a la synchronisation incrementale (polling) : on ne remonte
// que les messages posterieurs au dernier connu, dans l'ordre du temps.
// Sans `after` : les `limit` derniers, remis dans l'ordre croissant.
const rows =
after > 0
? await db.query<MessageRow>(
@@ -252,8 +208,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
const user = currentUser(context);
const folderId = context.req.param("folderId") ?? "";
await assertFolder(folderId);
// Etre membre du salon suffit a ecrire : un acces `read` participe a la
// discussion, exactement comme le proprietaire.
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
if (!limiter.allow(user.id)) {
@@ -272,12 +226,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
return context.json({ message: publicMessage(row) }, 201);
});
/**
* Edition d'un message. Seul l'auteur peut modifier ce qu'il a ecrit : le
* filtre `user_id = ?` est porte par la requete SQL, donc un message d'autrui
* est indistinguishable d'un message inexistant. Le gestionnaire du dossier
* peut supprimer un message, mais pas le reecrire a la place de son auteur.
*/
app.patch(
"/api/cloud/folders/:folderId/chat/messages/:id",
requireAuth,
@@ -321,11 +269,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
},
);
/**
* Epinglage d'un message. Bascule atomique en base : le salon compte
* plusieurs participants, deux clics croises ne doivent pas laisser le
* message dans un etat incoherent. Tout membre du salon peut epingler.
*/
app.put(
"/api/cloud/folders/:folderId/chat/messages/:id/pin",
requireAuth,
@@ -366,12 +309,6 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
},
);
/**
* Messages epingles du salon. Relu a chaque tour de synchronisation : le
* curseur `after` ne remonte que les messages plus recents, donc un
* epinglage pose sur un ancien message resterait invisible sans cette lecture
* dediee.
*/
app.get("/api/cloud/folders/:folderId/chat/pins", requireAuth, async (context) => {
const user = currentUser(context);
const folderId = context.req.param("folderId") ?? "";
@@ -403,15 +340,10 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
"SELECT user_id FROM chat_messages WHERE id = ? AND folder_id = ? AND deleted_at IS NULL",
[id, folderId],
);
// Auteur ou gestionnaire du dossier (proprietaire) : meme reponse qu'un
// message inexistant pour ne rien laisser deviner.
if (!row || (row.user_id !== user.id && !(await canManageFolder(db, user, folderId)))) {
throw AppError.notFound("Message introuvable.");
}
// Un message retire quitte aussi les epingles : le laisser marque ferait
// apparaitre un epingle fantome dans le bandeau. `deleted_at` suit la
// meme horloge que `created_at`.
await db.exec(
"UPDATE chat_messages SET deleted_at = CURRENT_TIMESTAMP(3), is_pinned = 0 WHERE id = ?",
[id],
-5
View File
@@ -7,11 +7,6 @@ import {
type Db,
} from "../lib/index.js";
/**
* Repertoire des comptes actifs, reduit au strict necessaire pour choisir un
* destinataire lors d'un partage. La session courante est exclue : on ne se
* partage pas un dossier a soi-meme. Aucune donnee sensible n'est exposee.
*/
export const registerDirectoryRoutes = (app: App, db: Db, config: Config): void => {
app.use("/api/cloud/directory", attachUser(db, config.SESSION_SECRET));
-51
View File
@@ -92,7 +92,6 @@ export const publicFile = (row: FileRow) => ({
updated_at: row.updated_at,
});
/** Nom d'affichage : ni separateur, ni sequence d'echappement, ni point seul. */
export const assertName = (raw: string | undefined): string => {
const name = (raw ?? "").trim();
if (!name || name.length > 255) {
@@ -109,7 +108,6 @@ export const mimeOf = (header: string | undefined): string => {
return MIME.test(value) ? value : "application/octet-stream";
};
/** Le nom HTTP ne contient que des octets ASCII imprimables, UTF-8 en prime. */
const contentDisposition = (name: string, inline = false): string => {
const ascii = name.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_");
const kind = inline ? "inline" : "attachment";
@@ -118,11 +116,6 @@ const contentDisposition = (name: string, inline = false): string => {
const BYTE_RANGE = /^bytes=(\d*)-(\d*)$/;
/**
* Analyse un en-tete `Range` (une seule plage). Rend `null` quand il faut servir
* le corps entier (absent ou illisible), `"invalid"` quand la plage est
* insatisfiable (reponse 416), sinon les bornes inclusives a servir.
*/
const parseRange = (
header: string | undefined,
total: number,
@@ -149,11 +142,6 @@ const parseRange = (
return { start, end };
};
/**
* Types servis en flux pour l'apercu en ligne. Liste blanche stricte : jamais
* `text/html`, `image/svg+xml` ni `application/xhtml+xml`, qui s'executeraient
* dans l'origine de l'application. Le telechargement, lui, reste `attachment`.
*/
const isPreviewable = (mime: string): boolean => {
const value = mime.toLowerCase();
if (value === "image/svg+xml") return false;
@@ -174,7 +162,6 @@ interface ServeOptions {
range: string | undefined;
}
/** Repond avec le fichier, en gerant `Range` (206) et les plages invalides (416). */
const serveFile = ({ absolute, size, mime, disposition, range }: ServeOptions): Response => {
const headers: Record<string, string> = {
"content-type": mime,
@@ -210,11 +197,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
app.use("/api/cloud/files/*", attachUser(db, config.SESSION_SECRET));
app.use("/api/cloud/files", attachUser(db, config.SESSION_SECRET));
/**
* Depot en un seul passage. Le corps n'est pas un formulaire multipart mais
* l'objet brut : le navigateur envoie le File tel quel, ce qui evite de
* faire tenir plusieurs gigaoctets en memoire pendant le decoupage.
*/
app.put(
"/api/cloud/files",
requireAuth,
@@ -258,7 +240,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
);
if (!budget) throw AppError.unauthorized();
// Les deux bornes sont verifiees avant d'ecrire quoi que ce soit.
if (declared > budget.max_file_bytes) {
throw AppError.payloadTooLarge(
`Fichier trop volumineux (maximum ${budget.max_file_bytes} octets).`,
@@ -268,11 +249,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
throw AppError.payloadTooLarge("Votre quota de stockage est depasse.");
}
// Un nom est unique dans un dossier, mais la racine est un espace
// personnel : chaque utilisateur y depose ses propres fichiers, et la
// liste n'en montre que les siens. Le controle de doublon doit donc
// suivre la meme regle, sinon le fichier d'un autre compte a la racine
// bloquerait un depot qui n'a rien a voir avec lui.
const duplicate = await db.one(
`SELECT 1 AS taken FROM files
WHERE folder_id <=> ? AND active_name = ? AND deleted_at IS NULL
@@ -282,9 +258,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
);
if (duplicate) throw AppError.conflict("Ce nom existe deja ici.");
// Le disque est verifie avant l'ecriture : sans cela un support plein
// ferait echouer le depot en cours de route (ENOSPC), apres avoir
// annonce au client que le quota etait disponible.
const disk = await diskUsage(config.MEDIA_DIR);
if (disk !== null && declared > disk.available_bytes) {
throw AppError.insufficientStorage(
@@ -311,8 +284,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
throw error;
}
// Publication puis ecriture en base : si la base refuse, le fichier
// est retire, il ne reste aucun orphelin dans les deux sens.
await publish(temporary, destination);
try {
@@ -364,8 +335,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
throw error;
}
// Vignette et metadonnees : best-effort, le depot reste valide si sharp
// echoue sur un format exotique.
await indexMedia(db, config, id, mimeOf(context.req.header("content-type")), destination).catch(
() => undefined,
);
@@ -395,8 +364,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
throw AppError.badRequest("Identifiant de dossier invalide.");
}
// Contre l'IDOR : un dossier qui n'appartient pas a la session rend une
// liste vide plutot que de confirmer son existence.
if (folderId !== null && !(await canRead(db, user, folderId))) {
const readable = await db.one(
`SELECT 1 AS granted FROM folders f
@@ -433,12 +400,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
return context.json({ folderId, files: rows.map(publicFile) });
});
/**
* Favoris : tous les fichiers etoiles accessibles a la session, tous dossiers
* confondus. Le filtre reprend exactement les droits de lecture de
* l'explorateur (proprietaire, dossier public, permission nominative), sans
* exception pour le role global.
*/
app.get("/api/cloud/favorites", requireAuth, async (context) => {
const user = currentUser(context);
const rows = await db.query<FileRow & { folder_name: string | null }>(
@@ -507,11 +468,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
});
});
/**
* Apercu en ligne (flux `inline`) : lecture d'une video ou d'un son, rendu
* d'une image ou d'un PDF. Memes droits que le telechargement, sans
* incrementation de `download_count`. Types sur liste blanche uniquement.
*/
app.get("/api/cloud/files/:id/preview", requireAuth, async (context) => {
const user = currentUser(context);
const rawId = context.req.param("id");
@@ -540,7 +496,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
});
});
/** Vignette d'image. Memes droits que le telechargement, cache prive. */
app.get("/api/cloud/files/:id/thumbnail", requireAuth, async (context) => {
const user = currentUser(context);
const rawId = context.req.param("id");
@@ -575,7 +530,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
});
});
/** Renomme un fichier. Le chemin physique ne bouge pas : il suit l'UUID. */
app.patch("/api/cloud/files/:id", requireAuth, async (context) => {
const user = currentUser(context);
const rawId = context.req.param("id");
@@ -610,7 +564,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
return context.json({ file: publicFile(updated) });
});
/** Deplace un fichier vers un autre dossier, racine comprise. */
app.post("/api/cloud/files/:id/move", requireAuth, async (context) => {
const user = currentUser(context);
const rawId = context.req.param("id");
@@ -646,7 +599,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
return context.json({ file: publicFile(updated) });
});
/** Bascule le marqueur favori. */
app.put("/api/cloud/files/:id/star", requireAuth, async (context) => {
const user = currentUser(context);
const rawId = context.req.param("id");
@@ -693,9 +645,6 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
(row.folder_id !== null && (await canWriteExplicit(db, user, row.folder_id)));
if (!permitted) throw AppError.notFound("Fichier introuvable.");
// Suppression logique : le fichier reste sur disque le temps de la
// retention (trash_retention_days), et son nom redevient disponible grace
// a la colonne active_name.
const result = await db.exec(
"UPDATE files SET deleted_at = UTC_TIMESTAMP() WHERE id = ? AND deleted_at IS NULL",
[row.id],
-12
View File
@@ -88,7 +88,6 @@ const parse = <T>(schema: z.ZodType<T>, body: unknown): T => {
return result.data;
};
/** Id du dossier et de tous ses descendants, y compris lui-meme. */
const subtreeIds = async (db: Db, rootId: string): Promise<string[]> => {
const rows = await db.query<{ id: string }>(
`WITH RECURSIVE subtree AS (
@@ -116,7 +115,6 @@ export const registerFolderRoutes = (app: App, db: Db, config: Config): void =>
}
if (parentId !== null) {
// Permet la traversée vers un sous-dossier partage.
if (!(await canTraverse(db, user, parentId))) {
throw AppError.notFound("Dossier introuvable.");
}
@@ -130,8 +128,6 @@ export const registerFolderRoutes = (app: App, db: Db, config: Config): void =>
[parentId],
);
// Un enfant est visible s'il est lisible directement ou s'il mene a un
// partage. Le role admin ne donne aucun droit special ici (voir access.ts).
const visible: FolderRow[] = [];
for (const row of rows) {
if (row.owner_id === user.id || (await canTraverse(db, user, row.id))) {
@@ -160,9 +156,6 @@ export const registerFolderRoutes = (app: App, db: Db, config: Config): void =>
}
}
// La racine est l'espace personnel de chaque compte : un dossier du meme
// nom cree par quelqu'un d'autre ne doit pas bloquer celui-ci. Dans un
// dossier, le nom reste unique pour tous ses participants.
const duplicate = await db.one(
`SELECT 1 AS taken FROM folders
WHERE parent_id <=> ? AND active_name = ? AND deleted_at IS NULL
@@ -256,8 +249,6 @@ export const registerFolderRoutes = (app: App, db: Db, config: Config): void =>
if (!(await canWrite(db, user, parentId))) {
throw AppError.forbidden("Vous ne pouvez pas ecrire dans ce dossier de destination.");
}
// Refuse un deplacement dans soi-meme ou dans un descendant : sans cela,
// l'arborescence se detache du graphe et devient inaccessible.
const descendants = await subtreeIds(db, id);
if (descendants.includes(parentId)) {
throw AppError.badRequest("Impossible de deplacer un dossier dans lui-meme.");
@@ -278,7 +269,6 @@ export const registerFolderRoutes = (app: App, db: Db, config: Config): void =>
return context.json({ folder: publicFolder(updated) });
});
/** Suppression logique recursive : le dossier, ses descendants et leurs fichiers. */
app.delete("/api/cloud/folders/:id", requireAuth, async (context) => {
const user = currentUser(context);
const id = context.req.param("id") ?? "";
@@ -306,8 +296,6 @@ export const registerFolderRoutes = (app: App, db: Db, config: Config): void =>
return context.json({ ok: true });
});
// --- Permissions nominatives -------------------------------------------
app.get("/api/cloud/folders/:id/permissions", requireAuth, async (context) => {
const user = currentUser(context);
const id = context.req.param("id") ?? "";
-6
View File
@@ -8,12 +8,6 @@ import {
type Db,
} from "../lib/index.js";
/**
* Galerie : liste des fichiers accompagnes de leur nature (image, video,
* document...), filtree par les memes droits que l'explorateur. Le dossier
* public et les permissions nominatives sont pris en compte, sans exception.
*/
const KINDS = ["image", "video", "audio", "document", "archive", "other"] as const;
export const registerMediaRoutes = (app: App, db: Db, config: Config): void => {
-7
View File
@@ -8,13 +8,6 @@ import {
type Db,
} from "../lib/index.js";
/**
* Recherche par nom, filtree par les droits de la session. Le motif est
* echappe : `%` et `_` saisis par l'utilisateur deviennent des caracteres
* litteraux, jamais des jokers SQL. L'echappement par defaut de LIKE (barre
* oblique inverse) suffit.
*/
const escapeLike = (value: string): string =>
value.replace(/[\\%_]/g, (match) => `\\${match}`);
-18
View File
@@ -18,12 +18,6 @@ const uuid = z
"Identifiant invalide.",
);
/**
* La corbeille se prete a l'echelle d'un compte : chacun ne voit et ne gere
* que ses propres elements supprimes. Un element supprime dont le parent est
* lui aussi supprime n'est pas liste : c'est la racine de la suppression qui
* porte l'action.
*/
const subtreeIds = async (db: Db, rootId: string): Promise<string[]> => {
const rows = await db.query<{ id: string }>(
`WITH RECURSIVE subtree AS (
@@ -37,7 +31,6 @@ const subtreeIds = async (db: Db, rootId: string): Promise<string[]> => {
return rows.map((row) => row.id);
};
/** Remonte la chaine des parents et annule leur suppression. */
const restoreAncestors = async (db: Db, folderId: string | null): Promise<void> => {
let current = folderId;
const guard = new Set<string>();
@@ -53,7 +46,6 @@ const restoreAncestors = async (db: Db, folderId: string | null): Promise<void>
}
};
/** Supprime physiquement des fichiers et rend leur espace aux quotas. */
const purgeFiles = async (db: Db, config: Config, fileIds: string[]): Promise<void> => {
if (fileIds.length === 0) return;
const placeholders = fileIds.map(() => "?").join(",");
@@ -70,8 +62,6 @@ const purgeFiles = async (db: Db, config: Config, fileIds: string[]): Promise<vo
fileIds,
);
// Les vignettes vivent dans VARIANT_DIR : sans cette etape, chaque purge
// laisse un .webp orphelin sur le disque (les lignes partent en cascade).
const variants = await db.query<{ path: string }>(
`SELECT path FROM file_variants WHERE file_id IN (${placeholders})`,
fileIds,
@@ -99,7 +89,6 @@ const purgeFiles = async (db: Db, config: Config, fileIds: string[]): Promise<vo
});
};
/** Suppression definitive d'un dossier : ses fichiers puis lui-meme. */
const purgeFolderTree = async (db: Db, config: Config, rootId: string): Promise<void> => {
const folderIds = await subtreeIds(db, rootId);
const folderPlaceholders = folderIds.map(() => "?").join(",");
@@ -164,8 +153,6 @@ export const registerTrashRoutes = (app: App, db: Db, config: Config): void => {
app.get("/api/cloud/trash", requireAuth, async (context) => {
const user = currentUser(context);
// Seuls les elements dont le parent n'est pas lui-meme supprime figurent en
// tete de corbeille : le reste suit la suppression du parent.
const folders = await db.query<TrashFolderRow>(
`SELECT f.id, f.parent_id, f.name, f.owner_id, f.access_type,
f.created_at, f.updated_at, f.deleted_at
@@ -308,7 +295,6 @@ export const registerTrashRoutes = (app: App, db: Db, config: Config): void => {
return context.json({ ok: true });
});
/** Vide la corbeille du compte appelant (tous les elements purges). */
app.delete("/api/cloud/trash", requireAuth, async (context) => {
const user = currentUser(context);
@@ -346,10 +332,6 @@ export const registerTrashRoutes = (app: App, db: Db, config: Config): void => {
});
};
/**
* Purge planifiee : les elements supprimes au-dela de la retention disparaissent
* au demarrage. Aucun ordonnanceur externe n'est requis.
*/
export const purgeExpiredTrash = async (db: Db, config: Config): Promise<number> => {
const setting = await db.one<{ setting_value: string }>(
"SELECT setting_value FROM settings WHERE setting_key = 'trash_retention_days'",
-33
View File
@@ -32,17 +32,6 @@ import {
} from "../storage.js";
import { SELECT_FILE, assertName, mimeOf, publicFile, type FileRow } from "./files.js";
/**
* Upload resumable pour les fichiers qui depassent la limite de corps de
* requete de Cloudflare. Le client envoie des morceaux sequentiels de 50 MiB,
* ce qui reste sous la limite de 100 MB des offres Free/Pro.
*
* Le fichier temporaire est prealloue et rempli a l'offset courant. Une
* session ne peut appartenir qu'a son createur, et les droits d'ecriture sont
* revalides au moment de la finalisation : un partage retire pendant l'envoi
* ne permet pas de publier le fichier.
*/
const uuid = z
.string()
.regex(
@@ -50,10 +39,8 @@ const uuid = z
"Identifiant invalide.",
);
/** 50 MiB : sous la limite Cloudflare (100 MB) avec une marge confortable. */
export const CHUNK_SIZE = 50 * 1024 * 1024;
/** Duree de vie d'une session abandonnee, avant purge du temporaire. */
const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
const createInput = z.object({
@@ -103,7 +90,6 @@ const sessionPublic = (row: UploadSessionRow) => ({
expiresAt: new Date(row.expires_at).toISOString(),
});
/** Supprime la session et son temporaire, sans bruit si deja absente. */
const dropSession = async (db: Db, row: UploadSessionRow): Promise<void> => {
await discard(row.temp_path);
await db.exec("DELETE FROM upload_sessions WHERE id = ?", [row.id]).catch(() => undefined);
@@ -172,9 +158,6 @@ export const registerUploadRoutes = (app: App, db: Db, config: Config): void =>
);
if (!budget) throw AppError.unauthorized();
// Les sessions en cours immobilisent deja une part du quota : sans
// cette somme, plusieurs envois simultanes pourraient chacun passer le
// controle puis depasser le quota au moment de la finalisation.
const pending = await db.one<{ bytes: number | string | null }>(
`SELECT COALESCE(SUM(size_bytes - received_bytes), 0) AS bytes
FROM upload_sessions
@@ -281,11 +264,6 @@ export const registerUploadRoutes = (app: App, db: Db, config: Config): void =>
const body = context.req.raw.body;
if (!body) throw AppError.badRequest("Corps de requete vide.");
// Ecriture d'abord, curseur ensuite : un morceau interrompu laisse le
// curseur intact, donc le prochain essai reecrit la meme plage sans creer
// de trou. Deux requetes concurrentes sur la meme plage ecrivent les
// memes octets : une seule avance le curseur, l'autre constate que le
// morceau est deja applique.
const written = await writeChunk(row.temp_path, offset, body, declared);
if (written !== declared) {
throw AppError.badRequest(
@@ -330,8 +308,6 @@ export const registerUploadRoutes = (app: App, db: Db, config: Config): void =>
throw AppError.notFound("Fichier temporaire introuvable. Relancez l'envoi.");
}
// La limite de taille est propre au compte : elle peut avoir baisse
// pendant un envoi long, il faut donc la reverifier avant de publier.
const budget = await db.one<{ max_file_bytes: number | string }>(
"SELECT max_file_bytes FROM users WHERE id = ? AND deleted_at IS NULL",
[user.id],
@@ -362,12 +338,8 @@ export const registerUploadRoutes = (app: App, db: Db, config: Config): void =>
const checksum = await hashFile(row.temp_path);
const destination = absolutePath(config.MEDIA_DIR, row.relative_path);
// Le dossier de l'emplacement peut ne pas encore exister : l'envoi direct
// le cree avant d'ecrire, l'envoi resumable ecrit d'abord dans .uploads.
await ensureDir(path.dirname(destination));
// Publication avant la base, comme le depot direct : si la transaction
// echoue, le temporaire est remis en place pour permettre un nouvel essai.
await publish(row.temp_path, destination);
try {
@@ -460,11 +432,6 @@ export const registerUploadRoutes = (app: App, db: Db, config: Config): void =>
});
};
/**
* Purge les sessions arrivees a echeance et les temporaires orphelins (session
* supprimee avec le dossier ou le compte, par exemple). Appelee au demarrage
* puis periodiquement par le service.
*/
export const purgeExpiredUploads = async (db: Db, config: Config): Promise<number> => {
const expired = await db.query<UploadSessionRow>(
`${SELECT_SESSION} WHERE expires_at <= UTC_TIMESTAMP()`,
-47
View File
@@ -6,14 +6,6 @@ import { Readable, Transform } from "node:stream";
import { pipeline } from "node:stream/promises";
import { AppError, type Db } from "./lib/index.js";
/**
* Chemin physique : ${MEDIA_DIR}/${slug emplacement}/${uuid}.
*
* Le nom affiche n'apparait jamais dans le chemin. Outre qu'il evite toute
* escape via "../", il empeche deux depots homonymes de se marcher dessus et
* rend l'arborescence disque ininteressante a parcourir pour un tiers.
*/
const SLUG = /^[a-z0-9][a-z0-9-]{0,99}$/;
const EXTENSION = /^[.][a-z0-9]{1,10}$/i;
@@ -22,7 +14,6 @@ export interface StoredLocation {
slug: string;
}
/** Extension conservee pour la lisibilite sur disque, jamais pour le routage. */
const extensionOf = (name: string): string => {
const ext = path.posix.extname(name);
return EXTENSION.test(ext) ? ext.toLowerCase() : "";
@@ -43,11 +34,6 @@ const resolveInside = (mediaDir: string, relative: string): string => {
export const absolutePath = (mediaDir: string, relative: string): string =>
resolveInside(mediaDir, relative);
/**
* Choix de l'emplacement : celui qui offre le plus de marge. Les comptes sont
* eux-memes plafonnes, donc cette valeur sert a ne pas remplir un support
* tandis qu'un autre reste vide.
*/
export const chooseLocation = async (db: Db, bytes: bigint): Promise<StoredLocation> => {
const rows = await db.query<{ id: number; slug: string; remaining: number | null }>(
`SELECT id, slug,
@@ -73,12 +59,6 @@ interface WriteResult {
checksum: string;
}
/**
* Ecrit le corps de la requete sur disque en une seule passe : hachage,
* comptage et gravure avancent ensemble, sans jamais faire tenir le fichier
* en memoire. La lecture est interrompue des que la borne est depassee, donc
* un envoi enorme ne remplit pas d'abord le disque pour echouer ensuite.
*/
export const writeBody = async (
destination: string,
body: ReadableStream<Uint8Array>,
@@ -103,8 +83,6 @@ export const writeBody = async (
const source = Readable.fromWeb(body as Parameters<typeof Readable.fromWeb>[0]);
await pipeline(source, meter, createWriteStream(destination, { flags: "wx" }));
// Taille declaree et taille recue doivent concorder : sans quoi le quota
// aurait ete reserve sur une valeur que le disque n'a pas confirmee.
if (received !== declared) {
throw AppError.badRequest(
`Longueur incoherente : ${declared} octets annonces, ${received} recus.`,
@@ -118,7 +96,6 @@ export const ensureDir = async (directory: string): Promise<void> => {
await mkdir(directory, { recursive: true });
};
/** Publie un fichier temporaire : meme systeme de fichiers, donc operation atomique. */
export const publish = async (temporary: string, destination: string): Promise<void> => {
await rename(temporary, destination);
};
@@ -130,17 +107,12 @@ export const discard = async (...paths: string[]): Promise<void> => {
export const temporaryPath = (mediaDir: string, slug: string): string =>
path.join(path.resolve(mediaDir), slug, `.upload-${randomUUID()}`);
/**
* Dossier des uploads resumables. Il reste sous MEDIA_DIR : le renommage
* final vers l'emplacement de stockage est donc atomique.
*/
export const uploadTempDir = (mediaDir: string): string =>
path.join(path.resolve(mediaDir), ".uploads");
export const uploadTempPath = (mediaDir: string, id: string): string =>
path.join(uploadTempDir(mediaDir), `${id}.part`);
/** Prealloue le temporaire a la taille annoncee, sans ecrire les octets. */
export const preallocateUpload = async (destination: string, size: number): Promise<void> => {
await ensureDir(path.dirname(destination));
const handle = await open(destination, "wx");
@@ -151,10 +123,6 @@ export const preallocateUpload = async (destination: string, size: number): Prom
}
};
/**
* Ecrit un morceau a l'offset courant. Le flux est borne : un client qui
* annonce une taille et en envoie davantage est coupe avant d'ecrire l'exces.
*/
export const writeChunk = async (
destination: string,
offset: number,
@@ -180,7 +148,6 @@ export const writeChunk = async (
return received;
};
/** SHA-256 du fichier complet, calcule au moment de la finalisation. */
export const hashFile = async (absolute: string): Promise<string> => {
const hash = createHash("sha256");
for await (const chunk of createReadStream(absolute)) {
@@ -189,7 +156,6 @@ export const hashFile = async (absolute: string): Promise<string> => {
return hash.digest("hex");
};
/** Fichiers `.part` abandonnes : utilises par la purge des sessions expirees. */
export const listUploadTemps = async (mediaDir: string): Promise<string[]> => {
const entries = await readdir(uploadTempDir(mediaDir)).catch(() => []);
return entries
@@ -206,24 +172,12 @@ export const fileExists = async (absolute: string): Promise<boolean> => {
}
};
/**
* Ouvre un fichier en lecture. `range` restreint le flux a un intervalle
* d'octets inclusif, ce qui permet de repondre a une requete HTTP `Range`
* (deplacement dans une video ou un morceau audio) sans lire tout le fichier.
*/
export const openForDownload = (absolute: string, range?: { start: number; end: number }) =>
createReadStream(absolute, range);
/**
* Occupation reelle du support qui porte `target`. Sert a refuser un quota
* plus grand que le disque et a prevenir un eclatement d'ENOSPC : l'espace
* logique (used_bytes) peut etre disponible alors que le disque est plein.
*/
export interface DiskUsage {
total_bytes: number;
/** Blocs libres, blocs reserves du systeme de fichiers inclus. */
free_bytes: number;
/** Blocs utilisables par le processus (hors reserve root). */
available_bytes: number;
}
@@ -236,7 +190,6 @@ export const diskUsage = async (target: string): Promise<DiskUsage | null> => {
available_bytes: Number(info.bavail * info.bsize),
};
} catch {
// Support absent ou non monté : l'appelant decide du repli.
return null;
}
};