CD — Déploiement / deploy (push) Failing after 25s
- logo embarque dans les e-mails (CID) et gabarit repense en mode sombre - favicon multi-tailles + icone PNG, logo a gauche du titre (app et auth) - modale de confirmation animee a la place de window.confirm - bouton retour et fil d'ariane dans l'explorateur --------- Co-authored-by: xEsiah <[email protected]> Reviewed-on: #4 Reviewed-by: Esiah <[email protected]> Co-authored-by: Gitea Actions <-[email protected]>
175 lines
5.7 KiB
JavaScript
175 lines
5.7 KiB
JavaScript
#!/usr/bin/env node
|
|
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)
|
|
--first <nom> Prenom (obligatoire a la creation)
|
|
--last <nom> Nom (obligatoire a la creation)
|
|
--role <slug> admin | user (defaut : admin)
|
|
--password <mdp> Mot de passe, sinon variable ADMIN_PASSWORD
|
|
--reset Reinitialise le mot de passe d'un compte existant
|
|
--help Cette aide`;
|
|
|
|
interface Args {
|
|
email: string;
|
|
first: string;
|
|
last: string;
|
|
role: string;
|
|
password?: string;
|
|
reset: boolean;
|
|
help: boolean;
|
|
}
|
|
|
|
const parseArgs = (argv: string[]): Args => {
|
|
const args: Args = { email: "", first: "", last: "", role: "admin", reset: false, help: false };
|
|
const value = (index: number): string => {
|
|
const next = argv[index + 1];
|
|
if (next === undefined || next.startsWith("--")) {
|
|
throw AppError.badRequest(`Valeur manquante pour ${argv[index]}`);
|
|
}
|
|
return next;
|
|
};
|
|
for (let index = 0; index < argv.length; index += 1) {
|
|
const arg = argv[index];
|
|
if (arg === undefined) continue;
|
|
if (arg === "--email") args.email = value(index++);
|
|
else if (arg === "--first") args.first = value(index++);
|
|
else if (arg === "--last") args.last = value(index++);
|
|
else if (arg === "--role") args.role = value(index++);
|
|
else if (arg === "--password") args.password = value(index++);
|
|
else if (arg === "--reset") args.reset = true;
|
|
else if (arg === "--help" || arg === "-h") args.help = true;
|
|
else throw AppError.badRequest(`Argument inconnu : ${arg}`);
|
|
}
|
|
return args;
|
|
};
|
|
|
|
/** Mot de passe aleatoire, lisible a la frappe, sans caractere ambigu. */
|
|
const generatePassword = (): string => {
|
|
const alphabet = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789";
|
|
const bytes = new Uint8Array(18);
|
|
globalThis.crypto.getRandomValues(bytes);
|
|
let out = "";
|
|
for (const byte of bytes) out += alphabet[byte % alphabet.length];
|
|
return out;
|
|
};
|
|
|
|
const main = async (argv: string[]): Promise<number> => {
|
|
let args: Args;
|
|
try {
|
|
args = parseArgs(argv);
|
|
} catch (error) {
|
|
console.error(` ${toSafeError(error).message}\n\n${USAGE}`);
|
|
return 2;
|
|
}
|
|
|
|
if (args.help) {
|
|
console.log(USAGE);
|
|
return 0;
|
|
}
|
|
if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(args.email)) {
|
|
console.error(" Adresse e-mail invalide.");
|
|
return 2;
|
|
}
|
|
|
|
let config;
|
|
try {
|
|
config = loadDbConfig();
|
|
} catch (error) {
|
|
if (error instanceof ConfigError) {
|
|
console.error(` Configuration invalide :\n - ${error.issues.join("\n - ")}`);
|
|
return 2;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
const { Db } = await import("./lib/index.js");
|
|
const db = new Db(config);
|
|
|
|
try {
|
|
const role = await db.one<{ id: number }>("SELECT id FROM roles WHERE slug = ?", [args.role]);
|
|
if (!role) {
|
|
console.error(` Role inconnu : ${args.role}`);
|
|
return 2;
|
|
}
|
|
|
|
const existing = await db.one<{ id: string }>(
|
|
"SELECT id FROM users WHERE active_email = ?",
|
|
[args.email],
|
|
);
|
|
|
|
if (existing && !args.reset) {
|
|
console.error(` Ce compte existe deja : ${args.email}`);
|
|
console.error(" Utilisez --reset pour reinitialiser son mot de passe.");
|
|
return 1;
|
|
}
|
|
|
|
const password = args.password ?? process.env.ADMIN_PASSWORD ?? generatePassword();
|
|
if (Buffer.byteLength(password) < 8) {
|
|
console.error(" Le mot de passe doit contenir au moins 8 caracteres.");
|
|
return 2;
|
|
}
|
|
const hash = await hashPassword(password);
|
|
|
|
if (existing) {
|
|
await db.exec(
|
|
`UPDATE users SET password_hash = ?, must_change_password = 1, password_changed_at = NULL,
|
|
is_active = 1, deleted_at = NULL
|
|
WHERE id = ?`,
|
|
[hash, existing.id],
|
|
);
|
|
console.log(` Mot de passe reinitialise pour ${args.email}`);
|
|
console.log(` Mot de passe : ${password}`);
|
|
console.log(" Un changement de mot de passe sera demande a la premiere connexion.");
|
|
return 0;
|
|
}
|
|
|
|
if (!args.first || !args.last) {
|
|
console.error(" --first et --last sont obligatoires a la creation.");
|
|
console.error(`\n${USAGE}`);
|
|
return 2;
|
|
}
|
|
|
|
const id = randomUUID();
|
|
await db.exec(
|
|
`INSERT INTO users (id, email, first_name, last_name, password_hash, role_id, must_change_password, password_changed_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, 1, NULL)`,
|
|
[id, args.email, args.first, args.last, hash, role.id],
|
|
);
|
|
|
|
console.log(` Compte cree : ${args.email} (${args.role})`);
|
|
console.log(` Mot de passe : ${password}`);
|
|
console.log(" Un changement de mot de passe sera demande a la premiere connexion.");
|
|
return 0;
|
|
} catch (error) {
|
|
const safe = toSafeError(error);
|
|
console.error(` Echec : ${safe.code} — ${safe.message}`);
|
|
return 1;
|
|
} finally {
|
|
await db.close().catch(() => undefined);
|
|
}
|
|
};
|
|
|
|
main(process.argv.slice(2)).then(
|
|
(code) => process.exit(code),
|
|
(error) => {
|
|
console.error(` Erreur inattendue : ${error instanceof Error ? error.message : String(error)}`);
|
|
process.exit(1);
|
|
},
|
|
);
|