@imenam/mcp-organizer 0.0.0-stage → 1.0.2

package/dist/src/cli/setup.js

@@ -0,0 +1,626 @@
+import dotenv from "dotenv";
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { askLine, askSecret } from "./prompt.js";
+import { resolveEnvFile } from "../core/env-file.js";
+import { databasePath } from "../core/db.js";
+import { setAccount } from "../core/accounts.js";
+import { Store } from "../core/store.js";
+import { DEFAULT_HOST, loadSiteConfig } from "../server/config.js";
+import { renderEnvFile, REMOVED_ENV_KEYS } from "../deploy/env-render.js";
+import { renderNginx, renderSystemdUnit, SERVICE_NAME, upstreamAddress } from "../deploy/templates.js";
+import { EmailSchema } from "../../shared/schemas/entities.schema.js";
+import { MIN_PASSWORD_LENGTH } from "../../shared/schemas/api.schema.js";
+/**
+ * Commande `mcp-organizer --setup` : installation du site.
+ *
+ * Elle demande (ou reçoit par options et variables `ORGANIZER_SETUP_*`) l'URL
+ * publique, l'écoute, le répertoire de données, la confiance dans le reverse
+ * proxy, la dictée (Groq) et l'e-mail (SMTP), puis le premier compte. Elle
+ * écrit le `.env` (fusionné avec l'existant, lisible par son seul
+ * propriétaire), l'unité systemd et le bloc nginx dans un dossier de sortie,
+ * crée le compte et affiche les étapes suivantes. Elle n'écrit aucun fichier
+ * système.
+ *
+ * Les secrets (clé Groq, URL SMTP, mot de passe) ne se passent jamais en
+ * argument : ils sont saisis sans écho, ou lus dans leur variable
+ * `ORGANIZER_SETUP_*`. Une valeur existante du `.env` est proposée par défaut
+ * et conservée en mode non interactif ; une valeur requise absente fait
+ * échouer la commande.
+ */
+/** Modèle de transcription Groq écrit par le setup. */
+export const TRANSCRIBE_MODEL = "whisper-large-v3-turbo";
+/** Compte système proposé pour exécuter le site. */
+export const DEFAULT_SERVICE_USER = "mcp-organizer";
+/** Fichiers écrits dans le dossier de sortie. */
+export const SYSTEMD_UNIT_FILENAME = `${SERVICE_NAME}.service`;
+export const NGINX_FILENAME = `${SERVICE_NAME}.nginx.conf`;
+const ENV_PREFIX = "ORGANIZER_SETUP_";
+/** Options à valeur (`--nom=valeur`), chacune avec sa variable `ORGANIZER_SETUP_NOM`. */
+const VALUE_OPTIONS = [
+    "public-url",
+    "port",
+    "host",
+    "data-dir",
+    "trust-proxy",
+    "mail-from",
+    "admin-email",
+    "admin-name",
+    "output-dir",
+    "install-dir",
+    "service-user",
+    "node",
+];
+const FLAG_OPTIONS = ["--setup", "--non-interactive", "--no-groq", "--no-smtp"];
+/** Secrets refusés en argument : nom de l'option → variable à utiliser. */
+const SECRET_OPTIONS = {
+    "groq-api-key": `${ENV_PREFIX}GROQ_API_KEY`,
+    "smtp-url": `${ENV_PREFIX}SMTP_URL`,
+    "admin-password": `${ENV_PREFIX}ADMIN_PASSWORD`,
+    password: `${ENV_PREFIX}ADMIN_PASSWORD`,
+};
+export const SETUP_USAGE = `Usage : mcp-organizer --setup [options]
+
+Installation du site : écrit le .env, l'unité systemd et le bloc nginx, et crée
+le premier compte. Sans terminal, ou avec --non-interactive, rien n'est demandé :
+chaque valeur requise vient d'une option ou de sa variable ORGANIZER_SETUP_<NOM>
+(--public-url → ORGANIZER_SETUP_PUBLIC_URL), sinon du .env existant.
+
+  --public-url=<url>       URL ouverte par les utilisateurs (https, ou http pour un hôte local)
+  --port=<n>               port d'écoute du site
+  --host=<adresse>         adresse d'écoute                       [${DEFAULT_HOST}]
+  --data-dir=<chemin>      répertoire de données                  [<package>/.organizer-data]
+  --trust-proxy=oui|non    lire l'adresse du client dans X-Forwarded-For (nginx)
+  --mail-from=<adresse>    expéditeur des e-mails, avec SMTP
+  --no-groq                désactiver la dictée vocale
+  --no-smtp                désactiver l'envoi d'e-mails
+  --admin-email=<adresse>  compte à créer, ou dont remplacer le mot de passe
+  --admin-name=<nom>       nom affiché de ce compte
+  --dotenv=<fichier>       fichier .env à écrire                  [<package>/.env]
+  --output-dir=<chemin>    dossier de l'unité systemd et du bloc nginx [<package>/deploy]
+  --install-dir=<chemin>   répertoire du dépôt dans l'unité        [<package>]
+  --service-user=<compte>  compte système de l'unité               [${DEFAULT_SERVICE_USER}]
+  --node=<chemin>          exécutable Node.js de l'unité           [node courant]
+  --non-interactive        ne rien demander
+
+Secrets, jamais en argument : saisis sans écho, ou lus dans
+  ORGANIZER_SETUP_GROQ_API_KEY     clé de l'API Groq (dictée)
+  ORGANIZER_SETUP_SMTP_URL         smtp://utilisateur:motdepasse@hote:587 ou smtps://…
+  ORGANIZER_SETUP_ADMIN_PASSWORD   mot de passe du compte (${MIN_PASSWORD_LENGTH} caractères minimum)`;
+class SetupError extends Error {
+}
+function fail(message) {
+    throw new SetupError(message);
+}
+const say = (line = "") => process.stdout.write(`${line}\n`);
+const step = (title) => say(`\n== ${title}`);
+function envNameOf(option) {
+    return `${ENV_PREFIX}${option.replace(/-/g, "_").toUpperCase()}`;
+}
+/** Lit les options ; une option inconnue, répétée ou secrète est refusée. */
+export function parseArgs(argv) {
+    const values = {};
+    for (const arg of argv) {
+        if (FLAG_OPTIONS.includes(arg) || arg.startsWith("--dotenv="))
+            continue;
+        if (!arg.startsWith("--"))
+            fail(`Argument inattendu : « ${arg} ». Les valeurs se passent en --nom=valeur.\n\n${SETUP_USAGE}`);
+        const body = arg.slice(2);
+        const eq = body.indexOf("=");
+        const name = eq === -1 ? body : body.slice(0, eq);
+        if (name in SECRET_OPTIONS) {
+            fail(`--${name} est refusé : un secret passé en argument reste lisible dans l'historique du shell et la liste des processus. Saisissez-le sans écho, ou définissez ${SECRET_OPTIONS[name]}.`);
+        }
+        if (!VALUE_OPTIONS.includes(name))
+            fail(`Option inconnue : --${name}.\n\n${SETUP_USAGE}`);
+        if (eq === -1)
+            fail(`--${name} attend une valeur : --${name}=<valeur>.`);
+        const option = name;
+        if (values[option] !== undefined)
+            fail(`--${name} est donné plusieurs fois.`);
+        values[option] = body.slice(eq + 1).trim();
+    }
+    for (const option of VALUE_OPTIONS) {
+        if (values[option] !== undefined)
+            continue;
+        const fromEnv = process.env[envNameOf(option)]?.trim();
+        if (fromEnv)
+            values[option] = fromEnv;
+    }
+    return {
+        values,
+        nonInteractive: argv.includes("--non-interactive") || !process.stdin.isTTY,
+        noGroq: argv.includes("--no-groq"),
+        noSmtp: argv.includes("--no-smtp"),
+    };
+}
+function secretFromEnv(name) {
+    const value = process.env[`${ENV_PREFIX}${name}`];
+    return value === undefined || value === "" ? undefined : value;
+}
+// --- Validation --------------------------------------------------------------
+const LOCAL_HOSTNAMES = new Set(["localhost", "127.0.0.1", "[::1]"]);
+function validatePublicUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error(`« ${raw} » n'est pas une URL absolue : attendu par exemple https://organizer.example.com.`);
+    }
+    if (url.protocol !== "https:" && url.protocol !== "http:")
+        throw new Error(`protocole ${url.protocol} refusé : https attendu.`);
+    if (url.search || url.hash || url.username || url.password)
+        throw new Error("l'URL ne doit contenir ni identifiants, ni paramètres, ni fragment.");
+    if (url.protocol === "http:" && !LOCAL_HOSTNAMES.has(url.hostname)) {
+        throw new Error(`un site exposé est servi en https (${url.hostname}) : http n'est admis que pour un essai local (localhost, 127.0.0.1).`);
+    }
+    const trimmed = url.pathname.replace(/\/+$/, "");
+    const basePath = trimmed === "" ? "/" : trimmed;
+    if (!/^\/[A-Za-z0-9._~\-/]*$/.test(basePath))
+        throw new Error(`chemin ${basePath} refusé : lettres, chiffres, « . _ ~ - / » seulement.`);
+    return { publicUrl: url.href.replace(/\/+$/, ""), basePath };
+}
+function validatePort(raw) {
+    const port = Number(raw);
+    if (!/^\d+$/.test(raw) || port < 1 || port > 65535)
+        throw new Error(`port invalide (${raw}) : entier entre 1 et 65535 attendu.`);
+    return port;
+}
+function validateHost(raw) {
+    if (net.isIP(raw) !== 0)
+        return raw;
+    if (/^[A-Za-z0-9]([A-Za-z0-9.-]*[A-Za-z0-9])?$/.test(raw))
+        return raw;
+    throw new Error(`adresse d'écoute invalide (${raw}) : une adresse IP ou un nom d'hôte, sans port ni crochets.`);
+}
+/** Adresse d'écoute de la boucle locale : `localhost`, `127.0.0.0/8` ou `::1`. */
+function isLoopbackHost(host) {
+    const lower = host.toLowerCase();
+    if (lower === "localhost" || lower === "::1")
+        return true;
+    return net.isIPv4(lower) && lower.startsWith("127.");
+}
+function validateBoolean(raw) {
+    const value = raw.trim().toLowerCase();
+    if (["o", "oui", "y", "yes", "1", "true"].includes(value))
+        return true;
+    if (["n", "non", "no", "0", "false"].includes(value))
+        return false;
+    throw new Error(`réponse invalide (${raw}) : oui ou non attendu.`);
+}
+function validatePath(raw) {
+    if (raw.trim() === "")
+        throw new Error("chemin vide.");
+    return path.resolve(raw.trim());
+}
+/** Chemin de la machine cible : un chemin POSIX absolu est gardé tel quel, un autre est résolu ici. */
+function validateTargetPath(raw) {
+    const value = raw.trim();
+    if (value.startsWith("/"))
+        return path.posix.normalize(value).replace(/\/+$/, "") || "/";
+    return validatePath(value);
+}
+function validateMailFrom(raw) {
+    if (!raw.includes("@"))
+        throw new Error(`expéditeur invalide (${raw}) : attendu par exemple Organizer <organizer@example.com>.`);
+    return raw;
+}
+function validateSmtpUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error("l'URL SMTP n'est pas une URL absolue : attendu smtp://utilisateur:motdepasse@hote:587 ou smtps://….");
+    }
+    if (url.protocol !== "smtp:" && url.protocol !== "smtps:")
+        throw new Error(`protocole ${url.protocol} refusé pour l'URL SMTP : smtp ou smtps attendu.`);
+    if (!url.hostname)
+        throw new Error("l'URL SMTP n'indique pas d'hôte.");
+    return raw;
+}
+function validateEmail(raw) {
+    const parsed = EmailSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new Error(`adresse e-mail invalide (${raw}).`);
+    return parsed.data;
+}
+function validateName(raw) {
+    const name = raw.trim();
+    if (name === "")
+        throw new Error("nom affiché vide.");
+    return name;
+}
+function validateServiceUser(raw) {
+    if (!/^[a-z_][a-z0-9_-]*$/.test(raw))
+        throw new Error(`compte système invalide (${raw}) : minuscules, chiffres, « _ » et « - ».`);
+    return raw;
+}
+function validateNodePath(raw) {
+    if (raw.trim() === "")
+        throw new Error("chemin vide.");
+    return raw.trim();
+}
+class Prompter {
+    args;
+    constructor(args) {
+        this.args = args;
+    }
+    get interactive() {
+        return !this.args.nonInteractive;
+    }
+    provided(option) {
+        return this.args.values[option];
+    }
+    /** Valeur d'une question : option, puis `.env` existant, puis défaut, puis saisie. */
+    async value(spec) {
+        const provided = this.provided(spec.option);
+        if (provided !== undefined) {
+            try {
+                const value = spec.validate(provided);
+                say(`  ${spec.question} : ${provided}`);
+                return value;
+            }
+            catch (err) {
+                fail(`--${spec.option} (ou ${envNameOf(spec.option)}) : ${err.message}`);
+            }
+        }
+        const fallback = spec.existing ?? spec.defaultValue;
+        if (!this.interactive) {
+            if (fallback === undefined)
+                fail(`Mode non interactif : --${spec.option} (ou ${envNameOf(spec.option)}) est requis.`);
+            try {
+                const value = spec.validate(fallback);
+                say(`  ${spec.question} : ${fallback}${spec.existing !== undefined ? " (conservé)" : " (défaut)"}`);
+                return value;
+            }
+            catch (err) {
+                fail(`${spec.question} : la valeur ${spec.existing !== undefined ? "du .env existant" : "par défaut"} est invalide, ${err.message} Passez --${spec.option}.`);
+            }
+        }
+        const proposed = fallback ?? spec.suggestion;
+        for (;;) {
+            const raw = await askLine(`${spec.question}${proposed !== undefined ? ` [${proposed}]` : ""}`);
+            const candidate = raw === "" ? proposed : raw;
+            if (candidate === undefined) {
+                process.stderr.write("  ! Une valeur est attendue.\n");
+                continue;
+            }
+            try {
+                return spec.validate(candidate);
+            }
+            catch (err) {
+                process.stderr.write(`  ! ${err.message}\n`);
+            }
+        }
+    }
+}
+/**
+ * Secret facultatif (clé Groq, URL SMTP) : variable `ORGANIZER_SETUP_*`, puis
+ * valeur existante, puis saisie sans écho. `null` désactive la fonction.
+ */
+async function optionalSecret(prompter, spec) {
+    const fromEnv = secretFromEnv(spec.envName);
+    if (spec.disabled) {
+        if (fromEnv !== undefined)
+            fail(`${spec.disableFlag} et ${ENV_PREFIX}${spec.envName} sont incompatibles : retirez l'un des deux.`);
+        say(`  ${spec.label} : désactivé (${spec.disableFlag}).`);
+        return null;
+    }
+    if (fromEnv !== undefined) {
+        try {
+            spec.validate(fromEnv);
+        }
+        catch (err) {
+            fail(`${ENV_PREFIX}${spec.envName} : ${err.message}`);
+        }
+        say(`  ${spec.label} : repris de ${ENV_PREFIX}${spec.envName}.`);
+        return fromEnv;
+    }
+    if (!prompter.interactive) {
+        say(spec.existing !== undefined ? `  ${spec.label} : conservé.` : `  ${spec.label} : non configuré, fonction désactivée.`);
+        return spec.existing ?? null;
+    }
+    const hint = spec.existing !== undefined ? "Entrée pour conserver, « - » pour désactiver" : "Entrée pour désactiver";
+    for (;;) {
+        const raw = (await askSecret(`${spec.label}, non affiché (${hint})`)).trim();
+        if (raw === "")
+            return spec.existing ?? null;
+        if (raw === "-")
+            return null;
+        try {
+            return spec.validate(raw);
+        }
+        catch (err) {
+            process.stderr.write(`  ! ${err.message}\n`);
+        }
+    }
+}
+async function readPassword(prompter) {
+    const fromEnv = secretFromEnv("ADMIN_PASSWORD");
+    if (fromEnv !== undefined) {
+        if (fromEnv.length < MIN_PASSWORD_LENGTH)
+            fail(`${ENV_PREFIX}ADMIN_PASSWORD doit faire au moins ${MIN_PASSWORD_LENGTH} caractères.`);
+        say(`  Mot de passe : repris de ${ENV_PREFIX}ADMIN_PASSWORD.`);
+        return fromEnv;
+    }
+    if (!prompter.interactive)
+        fail(`Mode non interactif : ${ENV_PREFIX}ADMIN_PASSWORD est requis pour créer le compte.`);
+    for (;;) {
+        const first = await askSecret(`Mot de passe, non affiché (${MIN_PASSWORD_LENGTH} caractères minimum)`);
+        if (first.length < MIN_PASSWORD_LENGTH) {
+            process.stderr.write(`  ! Le mot de passe doit faire au moins ${MIN_PASSWORD_LENGTH} caractères.\n`);
+            continue;
+        }
+        if ((await askSecret("Confirmation")) !== first) {
+            process.stderr.write("  ! Les deux saisies diffèrent.\n");
+            continue;
+        }
+        return first;
+    }
+}
+/** Résultat de `fn` sur la base existante du répertoire de données, `fallback` sans base. */
+function withExistingStore(dataDir, fallback, fn) {
+    if (!fs.existsSync(databasePath(dataDir)))
+        return fallback;
+    const store = Store.open(dataDir);
+    try {
+        return fn(store);
+    }
+    finally {
+        store.close();
+    }
+}
+async function planAccount(prompter, dataDir) {
+    const accounts = { count: withExistingStore(dataDir, 0, (store) => store.countUsers()) };
+    const given = prompter.provided("admin-email");
+    let email;
+    if (given !== undefined) {
+        email = await prompter.value({ option: "admin-email", question: "Adresse e-mail du compte", validate: validateEmail });
+    }
+    else if (accounts.count === 0) {
+        if (!prompter.interactive)
+            fail("Mode non interactif : aucun compte n'existe, --admin-email (ou ORGANIZER_SETUP_ADMIN_EMAIL) est requis pour créer le premier.");
+        email = await prompter.value({ option: "admin-email", question: "Adresse e-mail du premier compte", validate: validateEmail });
+    }
+    else {
+        const answer = prompter.interactive ? await askLine(`${accounts.count} compte(s) en base. Adresse d'un compte à créer ou dont remplacer le mot de passe (Entrée pour ne rien changer)`) : "";
+        if (answer === "") {
+            if (prompter.provided("admin-name") !== undefined)
+                fail("--admin-name est donné sans --admin-email : indiquez le compte à nommer.");
+            if (secretFromEnv("ADMIN_PASSWORD") !== undefined)
+                fail(`${ENV_PREFIX}ADMIN_PASSWORD est défini sans --admin-email : indiquez le compte dont remplacer le mot de passe.`);
+            say(`  Compte : inchangé (${accounts.count} compte(s) en base).`);
+            return null;
+        }
+        try {
+            email = validateEmail(answer);
+        }
+        catch (err) {
+            fail(err.message);
+        }
+    }
+    const current = withExistingStore(dataDir, undefined, (store) => store.findUserByEmail(email)?.displayName ?? undefined);
+    const displayName = prompter.provided("admin-name") !== undefined || current === undefined
+        ? await prompter.value({ option: "admin-name", question: "Nom affiché", validate: validateName })
+        : undefined;
+    if (current !== undefined && displayName === undefined)
+        say(`  Nom affiché : ${current} (conservé).`);
+    const password = await readPassword(prompter);
+    return { email, displayName, password };
+}
+// --- Écriture ----------------------------------------------------------------
+/** Écrit un fichier lisible par son seul propriétaire, par remplacement atomique. */
+function writePrivateFile(target, content) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const temporary = `${target}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, content, { mode: 0o600 });
+    try {
+        if (process.platform !== "win32")
+            fs.chmodSync(temporary, 0o600);
+        fs.renameSync(temporary, target);
+    }
+    catch (err) {
+        fs.rmSync(temporary, { force: true });
+        throw err;
+    }
+}
+function readExistingEnv(envFilePath) {
+    if (!fs.existsSync(envFilePath))
+        return undefined;
+    try {
+        return fs.readFileSync(envFilePath, "utf8");
+    }
+    catch (err) {
+        fail(`Le fichier ${envFilePath} existe mais ne peut pas être lu (${err?.message ?? err}) : corrigez ses droits, ou choisissez un autre fichier avec --dotenv.`);
+    }
+}
+function printNextSteps(answers, context, outputDir, local) {
+    step("Étapes suivantes");
+    const unit = path.join(outputDir, SYSTEMD_UNIT_FILENAME);
+    const nginx = path.join(outputDir, NGINX_FILENAME);
+    const serverName = new URL(answers.publicUrl).hostname;
+    if (local) {
+        say("  Essai local : lancez le site, puis ouvrez l'URL publique.");
+        say(`    node ${path.join(context.installDir, "dist", "src", "index.js")} --server --dotenv=${context.envFilePath}`);
+        say(`    ${answers.publicUrl}`);
+        return;
+    }
+    say("  À exécuter en root ; aucun fichier système n'a été écrit.");
+    say("");
+    say("  1. Compte de service et droits :");
+    say(`       useradd --system --no-create-home --shell /usr/sbin/nologin ${context.serviceUser}`);
+    say(`       chown -R ${context.serviceUser}:${context.serviceUser} ${answers.dataDir}`);
+    say(`       chown root:${context.serviceUser} ${context.envFilePath} && chmod 640 ${context.envFilePath}`);
+    say("");
+    say("  2. Service :");
+    say(`       cp ${unit} /etc/systemd/system/${SYSTEMD_UNIT_FILENAME}`);
+    say("       systemctl daemon-reload");
+    say(`       systemctl enable --now ${SERVICE_NAME}`);
+    say("");
+    say("  3. Certificat, puis nginx :");
+    say(`       certbot certonly --nginx -d ${serverName}`);
+    say(`       cp ${nginx} /etc/nginx/sites-available/${SERVICE_NAME}`);
+    say(`       ln -s /etc/nginx/sites-available/${SERVICE_NAME} /etc/nginx/sites-enabled/${SERVICE_NAME}`);
+    say("       nginx -t && systemctl reload nginx");
+    say("");
+    say("  4. Vérification :");
+    say(`       systemctl status ${SERVICE_NAME}`);
+    say(`       curl -sI http://${upstreamAddress(answers.host, answers.port)}/`);
+    say(`       ouvrir ${answers.publicUrl}`);
+    say(`     En cas d'échec : journalctl -u ${SERVICE_NAME} -n 50`);
+}
+// --- Commande ----------------------------------------------------------------
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export async function runSetup(argv, rootDir) {
+    try {
+        const args = parseArgs(argv);
+        const prompter = new Prompter(args);
+        const envFilePath = resolveEnvFile(argv, rootDir).path;
+        const existingText = readExistingEnv(envFilePath);
+        const existing = existingText === undefined ? {} : dotenv.parse(existingText);
+        const kept = (key) => (existing[key] === undefined || existing[key] === "" ? undefined : existing[key]);
+        say("mcp-organizer — installation du site");
+        say(existingText === undefined ? `  Nouveau fichier de configuration : ${envFilePath}` : `  Configuration existante relue : ${envFilePath}`);
+        step("Exposition");
+        const { publicUrl, basePath } = await prompter.value({
+            option: "public-url",
+            question: "URL publique du site",
+            existing: kept("ORGANIZER_PUBLIC_URL"),
+            suggestion: "https://organizer.example.com",
+            validate: validatePublicUrl,
+        });
+        const port = await prompter.value({ option: "port", question: "Port d'écoute", existing: kept("PORT"), suggestion: "4800", validate: validatePort });
+        const host = await prompter.value({ option: "host", question: "Adresse d'écoute", existing: kept("HOST"), defaultValue: DEFAULT_HOST, validate: validateHost });
+        const existingTrust = existing.ORGANIZER_TRUST_PROXY === undefined ? undefined : existing.ORGANIZER_TRUST_PROXY === "1" ? "oui" : existing.ORGANIZER_TRUST_PROXY === "" ? "non" : undefined;
+        const trustProxy = await prompter.value({
+            option: "trust-proxy",
+            question: "Adresse du client lue dans X-Forwarded-For (oui derrière nginx)",
+            existing: existingTrust,
+            suggestion: "oui",
+            validate: validateBoolean,
+        });
+        if (trustProxy && !isLoopbackHost(host)) {
+            fail(`--trust-proxy=oui avec l'adresse d'écoute ${host} est refusé : un site joignable sans passer par le reverse proxy reçoit des requêtes directes, dont l'en-tête X-Forwarded-For est écrit par le client lui-même. Il pourrait alors choisir l'adresse vue par le site et contourner la limitation des connexions. Gardez HOST=127.0.0.1 (ou ::1) derrière nginx, ou répondez non à --trust-proxy.`);
+        }
+        step("Données");
+        const dataDir = await prompter.value({
+            option: "data-dir",
+            question: "Répertoire de données",
+            existing: kept("MCP_ORGANIZER_DATA_DIR"),
+            defaultValue: path.join(rootDir, ".organizer-data"),
+            validate: validatePath,
+        });
+        step("Dictée vocale (Groq)");
+        const groqApiKey = await optionalSecret(prompter, {
+            envName: "GROQ_API_KEY",
+            label: "Clé de l'API Groq",
+            existing: kept("GROQ_API_KEY"),
+            disabled: args.noGroq,
+            disableFlag: "--no-groq",
+            validate: (raw) => raw,
+        });
+        step("E-mail (SMTP)");
+        if (args.noSmtp && prompter.provided("mail-from") !== undefined)
+            fail("--no-smtp et --mail-from sont incompatibles : retirez l'un des deux.");
+        const smtpUrl = await optionalSecret(prompter, {
+            envName: "SMTP_URL",
+            label: "URL SMTP",
+            existing: kept("SMTP_URL"),
+            disabled: args.noSmtp,
+            disableFlag: "--no-smtp",
+            validate: validateSmtpUrl,
+        });
+        let mailFrom = null;
+        if (smtpUrl === null) {
+            if (prompter.provided("mail-from") !== undefined)
+                fail("--mail-from est donné sans serveur SMTP : définissez ORGANIZER_SETUP_SMTP_URL, ou retirez --mail-from.");
+        }
+        else {
+            mailFrom = await prompter.value({ option: "mail-from", question: "Expéditeur des e-mails", existing: kept("MAIL_FROM"), suggestion: "Organizer <organizer@example.com>", validate: validateMailFrom });
+        }
+        step("Premier compte");
+        const account = await planAccount(prompter, dataDir);
+        const values = {
+            ORGANIZER_PUBLIC_URL: publicUrl,
+            ORGANIZER_BASE_PATH: basePath === "/" ? null : basePath,
+            PORT: String(port),
+            HOST: host,
+            // Vide plutôt qu'absent : la réponse « non » reste dans le fichier pour un setup relancé.
+            ORGANIZER_TRUST_PROXY: trustProxy ? "1" : "",
+            MCP_ORGANIZER_DATA_DIR: dataDir,
+            GROQ_API_KEY: groqApiKey,
+            ORGANIZER_TRANSCRIBE_MODEL: groqApiKey === null ? null : TRANSCRIBE_MODEL,
+            SMTP_URL: smtpUrl,
+            MAIL_FROM: mailFrom,
+        };
+        // Le site relira ce fichier : sa propre validation doit l'accepter.
+        try {
+            loadSiteConfig(Object.fromEntries(Object.entries(values).filter(([, value]) => value !== null)));
+        }
+        catch (err) {
+            fail(err.message);
+        }
+        const context = {
+            installDir: prompter.provided("install-dir") !== undefined ? validateOption("install-dir", prompter.provided("install-dir"), validateTargetPath) : rootDir,
+            envFilePath,
+            serviceUser: validateOption("service-user", prompter.provided("service-user") ?? DEFAULT_SERVICE_USER, validateServiceUser),
+            nodePath: validateOption("node", prompter.provided("node") ?? process.execPath, validateNodePath),
+        };
+        const outputDir = prompter.provided("output-dir") !== undefined ? validatePathOption("output-dir", prompter.provided("output-dir")) : path.join(rootDir, "deploy");
+        const answers = { publicUrl, basePath, host, port, dataDir };
+        step("Fichiers");
+        const envText = renderEnvFile(existingText, values);
+        writePrivateFile(envFilePath, envText);
+        say(`  ${envFilePath}`);
+        if (process.platform === "win32")
+            say("    Windows : les droits POSIX ne s'appliquent pas ; restreignez l'accès au fichier s'il est partagé.");
+        else
+            say("    droits 600 : lisible par son seul propriétaire.");
+        const removed = REMOVED_ENV_KEYS.filter((key) => existing[key] !== undefined);
+        if (removed.length > 0)
+            say(`    retirées : ${removed.join(", ")} (le compte vit en base).`);
+        fs.mkdirSync(outputDir, { recursive: true });
+        const unitPath = path.join(outputDir, SYSTEMD_UNIT_FILENAME);
+        const nginxPath = path.join(outputDir, NGINX_FILENAME);
+        fs.writeFileSync(unitPath, renderSystemdUnit(answers, context));
+        fs.writeFileSync(nginxPath, renderNginx(answers));
+        say(`  ${unitPath}`);
+        say(`  ${nginxPath}`);
+        if (account !== null) {
+            step("Compte");
+            const store = Store.open(dataDir);
+            try {
+                const { created, user } = await setAccount(store, account);
+                say(created ? `  Compte ${user.email} (${user.displayName}) créé, avec son espace personnel.` : `  Compte ${user.email} (${user.displayName}) : mot de passe remplacé, compte actif.`);
+            }
+            finally {
+                store.close();
+            }
+        }
+        step("Résumé");
+        say(`  Site : ${publicUrl}, écoute sur ${upstreamAddress(host, port)}${trustProxy ? ", X-Forwarded-For pris en compte" : ""}.`);
+        say(`  Données : ${dataDir}`);
+        say(`  Dictée : ${groqApiKey === null ? "désactivée (aucune clé Groq)" : `activée (${TRANSCRIBE_MODEL})`}.`);
+        say(`  E-mail : ${smtpUrl === null ? "désactivé (aucun serveur SMTP)" : `activé, expéditeur ${mailFrom}`}.`);
+        printNextSteps(answers, context, outputDir, new URL(publicUrl).protocol === "http:");
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`Installation interrompue : ${err?.message ?? err}\n`);
+        return 1;
+    }
+}
+function validateOption(option, raw, validate) {
+    try {
+        return validate(raw);
+    }
+    catch (err) {
+        fail(`--${option} (ou ${envNameOf(option)}) : ${err.message}`);
+    }
+}
+function validatePathOption(option, raw) {
+    return validateOption(option, raw, validatePath);
+}

package/dist/src/cli/watch.d.ts

@@ -0,0 +1,4 @@
+import { type AgentRequestSummary } from "../../shared/schemas/agent-tools.schema.js";
+/** Ligne d'une demande : une seule ligne, lisible telle quelle dans la notification. */
+export declare function formatRequestEvent(request: AgentRequestSummary): string;
+export declare function runWatchMode(tokenId: string | undefined): Promise<number>;