@imenam/mcp-organizer 0.0.0-stage → 1.0.2

package/dist/src/cli/backup.js

@@ -0,0 +1,126 @@
+import Database from "better-sqlite3";
+import fs from "node:fs";
+import path from "node:path";
+import { ATTACHMENTS_DIRNAME } from "../core/attachments.js";
+import { BUSY_TIMEOUT_MS, databasePath } from "../core/db.js";
+/**
+ * Commande `mcp-organizer --backup <fichier> [--force]` : sauvegarde du site,
+ * en service ou non.
+ *
+ * La base est copiée par l'API de sauvegarde de SQLite, qui produit un
+ * instantané cohérent même pendant les écritures du site. Les pièces jointes
+ * référencées par cet instantané sont ensuite copiées dans le dossier
+ * `<fichier>.attachments/`, sous leur nom de stockage. Une pièce jointe
+ * référencée mais introuvable fait échouer la sauvegarde, qui ne laisse alors
+ * rien derrière elle. Une destination existante est refusée, sauf `--force`
+ * qui la remplace. Hors Windows, le fichier de la base est créé avec les
+ * droits 600 et le dossier des pièces jointes avec les droits 700.
+ */
+const USAGE = "Usage : mcp-organizer --backup <fichier> [--force]";
+/** Suffixe du dossier des pièces jointes, à côté du fichier de la base. */
+export const ATTACHMENTS_BACKUP_SUFFIX = ".attachments";
+/** Droits POSIX appliqués aux fichiers de la sauvegarde ; Windows ne les connaît pas. */
+const PRIVATE_MODES = process.platform !== "win32";
+function parseArgs(argv) {
+    const rest = argv.slice(argv.indexOf("--backup") + 1);
+    const unknown = rest.filter((arg) => arg.startsWith("-") && arg !== "--force");
+    if (unknown.length > 0)
+        throw new Error(`Option inconnue : ${unknown.join(", ")}.\n${USAGE}`);
+    const positional = rest.filter((arg) => !arg.startsWith("-"));
+    if (positional.length === 0)
+        throw new Error(`--backup attend le fichier de sauvegarde à créer.\n${USAGE}`);
+    if (positional.length > 1)
+        throw new Error(`--backup attend un seul fichier (reçu : ${positional.join(", ")}).\n${USAGE}`);
+    return { target: path.resolve(positional[0]), force: rest.includes("--force") };
+}
+function megabytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1).replace(".", ",")} Mo`;
+}
+/** Sauvegarde la base de `dataDir` dans `target`, et ses pièces jointes à côté. */
+export async function backupSite(dataDir, target, force) {
+    const source = databasePath(dataDir);
+    if (!fs.existsSync(source))
+        throw new Error(`Aucune base à sauvegarder : ${source} n'existe pas. Vérifiez le répertoire de données (MCP_ORGANIZER_DATA_DIR, ou --dotenv vers le .env du site).`);
+    const attachmentsDir = `${target}${ATTACHMENTS_BACKUP_SUFFIX}`;
+    if (path.resolve(target) === path.resolve(source))
+        throw new Error("La destination est la base elle-même : choisissez un autre fichier.");
+    const existing = [target, attachmentsDir].filter((entry) => fs.existsSync(entry));
+    if (existing.length > 0 && !force)
+        throw new Error(`La destination existe déjà : ${existing.join(", ")}. Choisissez un autre fichier, ou ajoutez --force pour la remplacer.`);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const partial = `${target}.partial`;
+    const partialAttachments = `${attachmentsDir}.partial`;
+    fs.rmSync(partial, { force: true });
+    fs.rmSync(partialAttachments, { recursive: true, force: true });
+    try {
+        // La copie contient les empreintes des mots de passe et des jetons : lisible par son seul propriétaire dès sa création.
+        fs.writeFileSync(partial, "", { mode: 0o600, flag: "wx" });
+        if (PRIVATE_MODES)
+            fs.chmodSync(partial, 0o600);
+        const db = new Database(source, { fileMustExist: true });
+        try {
+            db.pragma(`busy_timeout = ${BUSY_TIMEOUT_MS}`);
+            await db.backup(partial);
+        }
+        finally {
+            db.close();
+        }
+        // La copie devient un fichier autonome, sans journal WAL à côté.
+        const copy = new Database(partial, { fileMustExist: true });
+        let storagePaths;
+        try {
+            copy.pragma("journal_mode = DELETE");
+            const integrity = copy.pragma("integrity_check", { simple: true });
+            if (integrity !== "ok")
+                throw new Error(`La copie de la base est corrompue (integrity_check : ${String(integrity)}).`);
+            storagePaths = copy.prepare("SELECT storage_path FROM attachments ORDER BY storage_path").all().map((row) => row.storage_path);
+        }
+        finally {
+            copy.close();
+        }
+        fs.mkdirSync(partialAttachments, { mode: 0o700 });
+        if (PRIVATE_MODES)
+            fs.chmodSync(partialAttachments, 0o700);
+        const attachmentsRoot = path.resolve(dataDir, ATTACHMENTS_DIRNAME) + path.sep;
+        const missing = [];
+        for (const storagePath of storagePaths) {
+            const file = path.resolve(dataDir, storagePath);
+            if (!file.startsWith(attachmentsRoot))
+                throw new Error(`Pièce jointe hors du dossier ${ATTACHMENTS_DIRNAME}/ : ${storagePath}.`);
+            if (!fs.existsSync(file)) {
+                missing.push(storagePath);
+                continue;
+            }
+            fs.copyFileSync(file, path.join(partialAttachments, path.relative(attachmentsRoot, file)));
+        }
+        if (missing.length > 0) {
+            throw new Error(`${missing.length} pièce(s) jointe(s) référencée(s) par la base sont introuvables dans ${attachmentsRoot} (${missing.slice(0, 5).join(", ")}${missing.length > 5 ? ", …" : ""}). Relancez la sauvegarde ; si l'erreur persiste, ces fichiers ont disparu du répertoire de données.`);
+        }
+        if (force) {
+            fs.rmSync(target, { force: true });
+            fs.rmSync(attachmentsDir, { recursive: true, force: true });
+        }
+        fs.renameSync(partial, target);
+        fs.renameSync(partialAttachments, attachmentsDir);
+        return { databaseFile: target, attachmentsDir, attachmentCount: storagePaths.length };
+    }
+    catch (err) {
+        fs.rmSync(partial, { force: true });
+        fs.rmSync(partialAttachments, { recursive: true, force: true });
+        throw err;
+    }
+}
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export async function runBackup(argv, dataDir) {
+    try {
+        const args = parseArgs(argv);
+        const result = await backupSite(dataDir, args.target, args.force);
+        process.stdout.write(`Base sauvegardée : ${result.databaseFile} (${megabytes(fs.statSync(result.databaseFile).size)}).\n` +
+            `Pièces jointes : ${result.attachmentCount} fichier(s) dans ${result.attachmentsDir}.\n`);
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`Sauvegarde interrompue : ${err?.message ?? err}\n`);
+        return 1;
+    }
+}

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

@@ -0,0 +1,7 @@
+/** Saisies au terminal des commandes interactives (`--set-user`, `--setup`). */
+/** Lit une réponse sans écho : l'interface de lecture écrit dans une sortie qui jette tout. */
+export declare function askSecret(question: string): Promise<string>;
+/** Pose une question en clair et renvoie la réponse sans espaces de bord. */
+export declare function askLine(question: string): Promise<string>;
+/** Pose une question en clair jusqu'à obtenir une valeur non vide. */
+export declare function ask(question: string): Promise<string>;

package/dist/src/cli/prompt.js

@@ -0,0 +1,40 @@
+import { Writable } from "node:stream";
+import { createInterface } from "node:readline/promises";
+/** Saisies au terminal des commandes interactives (`--set-user`, `--setup`). */
+/** Lit une réponse sans écho : l'interface de lecture écrit dans une sortie qui jette tout. */
+export async function askSecret(question) {
+    process.stdout.write(`  ${question} : `);
+    const sink = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        },
+    });
+    const rl = createInterface({ input: process.stdin, output: sink, terminal: true });
+    try {
+        const answer = await rl.question("");
+        process.stdout.write("\n");
+        return answer;
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Pose une question en clair et renvoie la réponse sans espaces de bord. */
+export async function askLine(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(`  ${question} : `)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Pose une question en clair jusqu'à obtenir une valeur non vide. */
+export async function ask(question) {
+    for (;;) {
+        const value = await askLine(question);
+        if (value !== "")
+            return value;
+        process.stderr.write("  ! Une valeur est attendue.\n");
+    }
+}

package/dist/src/cli/set-user.d.ts

@@ -0,0 +1,2 @@
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export declare function runSetUser(argv: readonly string[], dataDir: string): Promise<number>;

package/dist/src/cli/set-user.js

@@ -0,0 +1,114 @@
+import { ask, askSecret } from "./prompt.js";
+import { setAccount } from "../core/accounts.js";
+import { Store } from "../core/store.js";
+import { MIN_PASSWORD_LENGTH } from "../../shared/schemas/api.schema.js";
+/**
+ * Commande `mcp-organizer --set-user [email] [--name="Prénom Nom"]` : crée un
+ * compte actif (avec son espace personnel) ou remplace le mot de passe d'un
+ * compte existant, qui redevient actif.
+ *
+ * Le mot de passe n'est jamais passé en argument. Il est saisi sans écho, avec
+ * confirmation ; en mode non interactif (`--non-interactive`, ou entrée qui
+ * n'est pas un terminal), il vient de `ORGANIZER_ADMIN_PASSWORD`. L'adresse
+ * vient de l'argument, puis de `ORGANIZER_ADMIN_EMAIL`, puis de la saisie. Le
+ * nom affiché vient de `--name`, puis de `ORGANIZER_ADMIN_NAME`, puis de la
+ * saisie ; il est requis pour créer un compte, facultatif pour un compte qui
+ * en a déjà un.
+ */
+const USAGE = [
+    'Usage : mcp-organizer --set-user [email] [--name="Prénom Nom"] [--non-interactive]',
+    "        Le mot de passe est demandé sans écho ; en mode non interactif,",
+    "        il vient de ORGANIZER_ADMIN_PASSWORD.",
+];
+const NAME_FLAG = "--name=";
+function fail(...lines) {
+    throw new Error(lines.join("\n"));
+}
+/** Arguments qui suivent `--set-user` : l'adresse facultative et les options. */
+function parseArgs(argv) {
+    const index = argv.indexOf("--set-user");
+    const rest = argv.slice(index + 1);
+    const positional = rest.filter((arg) => !arg.startsWith("-"));
+    if (positional.length > 1) {
+        fail("Le mot de passe ne se passe pas en argument : il resterait en clair dans l'historique du shell et la liste des processus.", "", ...USAGE);
+    }
+    const unknown = rest.filter((arg) => arg.startsWith("-") && arg !== "--non-interactive" && !arg.startsWith(NAME_FLAG));
+    if (unknown.length > 0)
+        fail(`Option inconnue : ${unknown.join(", ")}.`, "", ...USAGE);
+    const names = rest.filter((arg) => arg.startsWith(NAME_FLAG)).map((arg) => arg.slice(NAME_FLAG.length).trim());
+    if (names.length > 1)
+        fail("--name est donné plusieurs fois.", "", ...USAGE);
+    if (names[0] === "")
+        fail('--name attend le nom affiché : --name="Prénom Nom".', "", ...USAGE);
+    return { email: positional[0], name: names[0], nonInteractive: rest.includes("--non-interactive") || !process.stdin.isTTY };
+}
+async function readPassword(nonInteractive) {
+    const fromEnv = process.env.ORGANIZER_ADMIN_PASSWORD;
+    if (fromEnv) {
+        if (!nonInteractive)
+            process.stdout.write("  Mot de passe : repris de ORGANIZER_ADMIN_PASSWORD.\n");
+        if (fromEnv.length < MIN_PASSWORD_LENGTH)
+            fail(`ORGANIZER_ADMIN_PASSWORD doit faire au moins ${MIN_PASSWORD_LENGTH} caractères.`);
+        return fromEnv;
+    }
+    if (nonInteractive)
+        fail("Mode non interactif : ORGANIZER_ADMIN_PASSWORD est requis.");
+    for (;;) {
+        const first = await askSecret(`Mot de passe (${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;
+        }
+        const second = await askSecret("Confirmation");
+        if (first !== second) {
+            process.stderr.write("  ! Les deux saisies diffèrent.\n");
+            continue;
+        }
+        return first;
+    }
+}
+/**
+ * Nom affiché à poser : celui de `--name` ou de `ORGANIZER_ADMIN_NAME`, sinon
+ * la saisie quand le compte n'en a pas encore. Undefined garde le nom actuel.
+ */
+async function readName(store, email, args) {
+    const given = args.name ?? process.env.ORGANIZER_ADMIN_NAME?.trim();
+    if (given)
+        return given;
+    if (store.findUserByEmail(email.trim().toLowerCase())?.displayName)
+        return undefined;
+    if (args.nonInteractive) {
+        fail('Mode non interactif : le nom affiché du compte est requis. Passez --name="Prénom Nom" ou définissez ORGANIZER_ADMIN_NAME.', "", ...USAGE);
+    }
+    return ask("Nom affiché (ex. Matthieu Pin)");
+}
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export async function runSetUser(argv, dataDir) {
+    try {
+        const args = parseArgs(argv);
+        let email = args.email ?? process.env.ORGANIZER_ADMIN_EMAIL?.trim();
+        if (!email) {
+            if (args.nonInteractive)
+                fail("Mode non interactif : passez l'adresse en argument ou définissez ORGANIZER_ADMIN_EMAIL.", "", ...USAGE);
+            process.stdout.write("Compte à créer, ou compte dont remplacer le mot de passe.\n");
+            email = await ask("Adresse e-mail");
+        }
+        const store = Store.open(dataDir);
+        try {
+            const displayName = await readName(store, email, args);
+            const password = await readPassword(args.nonInteractive);
+            const { created, user } = await setAccount(store, { email, password, displayName });
+            process.stdout.write(created
+                ? `Compte ${user.email} (${user.displayName}) créé, avec son espace personnel (données : ${dataDir}).\n`
+                : `Compte ${user.email} (${user.displayName}) : mot de passe remplacé, compte actif, sessions ouvertes fermées.\n`);
+        }
+        finally {
+            store.close();
+        }
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`${err?.message ?? err}\n`);
+        return 1;
+    }
+}

package/dist/src/cli/setup-mcp.d.ts

@@ -0,0 +1,10 @@
+export interface SetupOptions {
+    force: boolean;
+    /** URL publique du site, sans barre oblique finale. */
+    url: string;
+    token: string;
+}
+/** Lit les options de la commande ; une option inconnue, absente ou invalide est une erreur. */
+export declare function parseSetupArgs(argv: readonly string[]): SetupOptions;
+/** Exécute la commande dans `cwd` ; renvoie le code de sortie. */
+export declare function runSetupMcp(argv: readonly string[], cwd: string): number;

package/dist/src/cli/setup-mcp.js

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import path from "node:path";
+import { SERVER_NAME, buildAgentEntry } from "../core/mcp-entry.js";
+import { AGENT_TOKEN_PREFIX } from "../../shared/schemas/tokens-api.schema.js";
+/**
+ * Commande `mcp-organizer --claude-setup-mcp` : écrit ou fusionne l'entrée
+ * `mcp-organizer` de `<cwd>/.mcp.json` (mode MCP relié à un site par son URL
+ * et un jeton d'agent), en conservant les autres serveurs. Un fichier
+ * illisible fait échouer la commande sans rien écrire.
+ */
+const USAGE = "Usage : npx -y @imenam/mcp-organizer --claude-setup-mcp [--force] --url=<URL du site> --token=<jeton d'agent>";
+/** Valeur d'une option `--nom=valeur`, ou undefined si elle est absente. */
+function readFlag(argv, name) {
+    const prefix = `--${name}=`;
+    const values = argv.filter((arg) => arg.startsWith(prefix)).map((arg) => arg.slice(prefix.length).trim());
+    if (values.length > 1)
+        throw new Error(`--${name} est donné plusieurs fois.`);
+    return values[0];
+}
+function checkUrl(raw) {
+    if (raw === undefined || raw === "")
+        throw new Error(`--url est requis : l'URL publique du site mcp-organizer (ex : https://organizer.example.com).\n${USAGE}`);
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        throw new Error(`--url invalide : « ${raw} » n'est pas une URL absolue (ex : https://organizer.example.com).`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+        throw new Error(`--url invalide : protocole « ${parsed.protocol} » non pris en charge (http ou https attendu).`);
+    if (parsed.search || parsed.hash || parsed.username || parsed.password)
+        throw new Error(`--url invalide : ni identifiants, ni paramètres, ni fragment (${raw}).`);
+    return parsed.href.replace(/\/+$/, "");
+}
+function checkToken(raw) {
+    if (raw === undefined || raw === "")
+        throw new Error(`--token est requis : un jeton d'agent créé sur le site (Paramètres > Agents).\n${USAGE}`);
+    if (!raw.startsWith(AGENT_TOKEN_PREFIX))
+        throw new Error(`--token invalide : un jeton d'agent commence par « ${AGENT_TOKEN_PREFIX} ». Copiez-le depuis Paramètres > Agents.`);
+    return raw;
+}
+/** Lit les options de la commande ; une option inconnue, absente ou invalide est une erreur. */
+export function parseSetupArgs(argv) {
+    const unknown = argv.filter((arg) => arg !== "--claude-setup-mcp" && arg !== "--force" && !arg.startsWith("--url=") && !arg.startsWith("--token="));
+    if (unknown.length > 0)
+        throw new Error(`Option inconnue : ${unknown.join(", ")}.\n${USAGE}`);
+    return { force: argv.includes("--force"), url: checkUrl(readFlag(argv, "url")), token: checkToken(readFlag(argv, "token")) };
+}
+/** Contenu actuel de `.mcp.json` : un objet, ou une erreur qui dit quoi corriger. */
+function readConfig(target) {
+    if (!fs.existsSync(target))
+        return { config: {}, exists: false };
+    let raw;
+    try {
+        raw = fs.readFileSync(target, "utf-8");
+    }
+    catch (err) {
+        throw new Error(`${target} est illisible (${err?.message ?? err}). Corrigez ses droits, puis relancez la commande.`);
+    }
+    if (raw.trim() === "")
+        return { config: {}, exists: true };
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`${target} contient du JSON invalide (${err?.message ?? err}). Corrigez le fichier ou supprimez-le, puis relancez la commande.`);
+    }
+    if (typeof config !== "object" || config === null || Array.isArray(config)) {
+        throw new Error(`${target} ne contient pas un objet JSON. Corrigez le fichier ou supprimez-le, puis relancez la commande.`);
+    }
+    const servers = config.mcpServers;
+    if (servers !== undefined && (typeof servers !== "object" || servers === null || Array.isArray(servers))) {
+        throw new Error(`${target} : « mcpServers » n'est pas un objet. Corrigez le fichier, puis relancez la commande.`);
+    }
+    return { config: config, exists: true };
+}
+/** Exécute la commande dans `cwd` ; renvoie le code de sortie. */
+export function runSetupMcp(argv, cwd) {
+    try {
+        const options = parseSetupArgs(argv);
+        const target = path.join(cwd, ".mcp.json");
+        const { config, exists } = readConfig(target);
+        const servers = config.mcpServers ?? {};
+        const alreadyPresent = Object.prototype.hasOwnProperty.call(servers, SERVER_NAME);
+        if (alreadyPresent && !options.force) {
+            throw new Error(`Le serveur « ${SERVER_NAME} » est déjà configuré dans ${target}.\nRelancez avec --force pour remplacer cette entrée (les autres serveurs sont conservés).`);
+        }
+        config.mcpServers = { ...servers, [SERVER_NAME]: buildAgentEntry({ url: options.url, token: options.token }) };
+        fs.writeFileSync(target, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        const action = alreadyPresent ? "remplacée" : exists ? "ajoutée" : "créée";
+        const lines = [
+            `Configuration ${SERVER_NAME} ${action} dans ${target}`,
+            "",
+            "Variables du champ « env » :",
+            `  ORGANIZER_URL    ${options.url}  URL publique du site`,
+            `  ORGANIZER_TOKEN  ${options.token.slice(0, AGENT_TOKEN_PREFIX.length + 8)}…  jeton d'agent : il couvre un espace, avec les droits de son créateur`,
+            "",
+            "Le jeton est un secret : .mcp.json ne doit pas être partagé ni versionné. Il se révoque depuis Paramètres > Agents.",
+            "",
+        ];
+        process.stdout.write(lines.join("\n"));
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`Erreur : ${err?.message ?? err}\n`);
+        return 1;
+    }
+}

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

@@ -0,0 +1,39 @@
+/**
+ * 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 declare const TRANSCRIBE_MODEL = "whisper-large-v3-turbo";
+/** Compte système proposé pour exécuter le site. */
+export declare const DEFAULT_SERVICE_USER = "mcp-organizer";
+/** Fichiers écrits dans le dossier de sortie. */
+export declare const SYSTEMD_UNIT_FILENAME = "mcp-organizer.service";
+export declare const NGINX_FILENAME = "mcp-organizer.nginx.conf";
+/** Options à valeur (`--nom=valeur`), chacune avec sa variable `ORGANIZER_SETUP_NOM`. */
+declare const VALUE_OPTIONS: readonly ["public-url", "port", "host", "data-dir", "trust-proxy", "mail-from", "admin-email", "admin-name", "output-dir", "install-dir", "service-user", "node"];
+type ValueOption = (typeof VALUE_OPTIONS)[number];
+export declare const SETUP_USAGE = "Usage : mcp-organizer --setup [options]\n\nInstallation du site : \u00E9crit le .env, l'unit\u00E9 systemd et le bloc nginx, et cr\u00E9e\nle premier compte. Sans terminal, ou avec --non-interactive, rien n'est demand\u00E9 :\nchaque valeur requise vient d'une option ou de sa variable ORGANIZER_SETUP_<NOM>\n(--public-url \u2192 ORGANIZER_SETUP_PUBLIC_URL), sinon du .env existant.\n\n  --public-url=<url>       URL ouverte par les utilisateurs (https, ou http pour un h\u00F4te local)\n  --port=<n>               port d'\u00E9coute du site\n  --host=<adresse>         adresse d'\u00E9coute                       [127.0.0.1]\n  --data-dir=<chemin>      r\u00E9pertoire de donn\u00E9es                  [<package>/.organizer-data]\n  --trust-proxy=oui|non    lire l'adresse du client dans X-Forwarded-For (nginx)\n  --mail-from=<adresse>    exp\u00E9diteur des e-mails, avec SMTP\n  --no-groq                d\u00E9sactiver la dict\u00E9e vocale\n  --no-smtp                d\u00E9sactiver l'envoi d'e-mails\n  --admin-email=<adresse>  compte \u00E0 cr\u00E9er, ou dont remplacer le mot de passe\n  --admin-name=<nom>       nom affich\u00E9 de ce compte\n  --dotenv=<fichier>       fichier .env \u00E0 \u00E9crire                  [<package>/.env]\n  --output-dir=<chemin>    dossier de l'unit\u00E9 systemd et du bloc nginx [<package>/deploy]\n  --install-dir=<chemin>   r\u00E9pertoire du d\u00E9p\u00F4t dans l'unit\u00E9        [<package>]\n  --service-user=<compte>  compte syst\u00E8me de l'unit\u00E9               [mcp-organizer]\n  --node=<chemin>          ex\u00E9cutable Node.js de l'unit\u00E9           [node courant]\n  --non-interactive        ne rien demander\n\nSecrets, jamais en argument : saisis sans \u00E9cho, ou lus dans\n  ORGANIZER_SETUP_GROQ_API_KEY     cl\u00E9 de l'API Groq (dict\u00E9e)\n  ORGANIZER_SETUP_SMTP_URL         smtp://utilisateur:motdepasse@hote:587 ou smtps://\u2026\n  ORGANIZER_SETUP_ADMIN_PASSWORD   mot de passe du compte (8 caract\u00E8res minimum)";
+interface ParsedArgs {
+    values: Partial<Record<ValueOption, string>>;
+    nonInteractive: boolean;
+    noGroq: boolean;
+    noSmtp: boolean;
+}
+/** Lit les options ; une option inconnue, répétée ou secrète est refusée. */
+export declare function parseArgs(argv: readonly string[]): ParsedArgs;
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export declare function runSetup(argv: readonly string[], rootDir: string): Promise<number>;
+export {};