@y4wee/nupo 0.1.0

package/dist/screens/InstallVersionScreen.js

@@ -0,0 +1,495 @@
+import React, { useReducer, useEffect, useState, useCallback, useRef } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { mkdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { getPrimaryColor, getSecondaryColor, getTextColor, getCursorColor, } from '../types/index.js';
+import { checkBranch, cloneRepo, ODOO_COMMUNITY_URL, ODOO_ENTERPRISE_URL, } from '../services/git.js';
+import { createVenv, installRequirements } from '../services/python.js';
+import { readConfig, writeConfig } from '../services/config.js';
+import { LeftPanel } from '../components/LeftPanel.js';
+import { StepsPanel } from '../components/StepsPanel.js';
+import { ErrorPanel } from '../components/ErrorPanel.js';
+import { ProgressBar } from '../components/ProgressBar.js';
+const STEP_DEFS = [
+    { id: 'branch_input', label: 'Saisie de la version' },
+    { id: 'check_community', label: 'Vérification branche community' },
+    { id: 'check_enterprise', label: 'Vérification branche enterprise' },
+    { id: 'create_dir', label: 'Création du dossier' },
+    { id: 'clone_community', label: 'Téléchargement Odoo community' },
+    { id: 'clone_enterprise', label: 'Téléchargement Odoo enterprise' },
+    { id: 'create_venv', label: 'Création de l\'environnement virtuel Python' },
+    { id: 'install_requirements', label: 'Installation des dépendances Python' },
+    { id: 'create_extras', label: 'Création dossiers custom et config' },
+];
+function reducer(state, action) {
+    if (action.type === 'RESET')
+        return action.steps;
+    return state.map(s => s.id === action.id ? { ...s, status: action.status, errorMessage: action.errorMessage } : s);
+}
+function buildInitialSteps() {
+    return STEP_DEFS.map((def, i) => ({
+        ...def,
+        status: (i === 0 ? 'running' : 'pending'),
+    }));
+}
+/** Builds steps for a resume: steps up to lastCompletedStep are success, rest pending. */
+function buildResumedSteps(lastCompletedStep) {
+    const lastIdx = lastCompletedStep
+        ? STEP_DEFS.findIndex(s => s.id === lastCompletedStep)
+        : -1;
+    return STEP_DEFS.map((def, i) => ({
+        ...def,
+        status: (i <= lastIdx ? 'success' : 'pending'),
+    }));
+}
+async function dirExists(p) {
+    try {
+        return (await stat(p)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+const PHASE_LABEL = {
+    receiving: 'Receiving objects',
+    resolving: 'Resolving deltas ',
+};
+// ── Screen ──────────────────────────────────────────────────────────────────
+export function InstallVersionScreen({ config, leftWidth, onComplete, onBack, }) {
+    const textColor = getTextColor(config);
+    const cursorColor = getCursorColor(config);
+    const [steps, dispatch] = useReducer(reducer, buildInitialSteps());
+    const [currentStepIndex, setCurrentStepIndex] = useState(0);
+    const [branchInput, setBranchInput] = useState('');
+    const [inputError, setInputError] = useState(null);
+    const [branchName, setBranchName] = useState('');
+    const [versionPath, setVersionPath] = useState('');
+    const [done, setDone] = useState(false);
+    const [cloneProgress, setCloneProgress] = useState(null);
+    const [pipOutput, setPipOutput] = useState('');
+    const [retryCount, setRetryCount] = useState(0);
+    const [errorAction, setErrorAction] = useState(0); // 0 = Relancer, 1 = Retour
+    const [focus, setFocus] = useState('input');
+    const [pendingSelected, setPendingSelected] = useState(0);
+    const [installedSelected, setInstalledSelected] = useState(0);
+    // Refs for use inside async callbacks
+    const dispatchRef = useRef(dispatch);
+    dispatchRef.current = dispatch;
+    const onCompleteRef = useRef(onComplete);
+    onCompleteRef.current = onComplete;
+    const branchNameRef = useRef('');
+    const versionPathRef = useRef('');
+    const pendingInstalls = Object.values(config.pending_installs ?? {});
+    const installedVersions = Object.values(config.odoo_versions ?? {});
+    // ── Handlers defined before useInput ──────────────────────────────────────
+    const handleRetry = () => {
+        const step = STEP_DEFS[currentStepIndex];
+        if (!step)
+            return;
+        dispatch({ type: 'SET_STATUS', id: step.id, status: 'pending', errorMessage: undefined });
+        setRetryCount(c => c + 1);
+    };
+    const handleReinstall = (version) => {
+        branchNameRef.current = version.branch;
+        versionPathRef.current = version.path;
+        setBranchName(version.branch);
+        setVersionPath(version.path);
+        dispatch({ type: 'RESET', steps: buildResumedSteps('branch_input') });
+        setCurrentStepIndex(1);
+    };
+    const handleResume = (pending) => {
+        branchNameRef.current = pending.branch;
+        versionPathRef.current = pending.path;
+        setBranchName(pending.branch);
+        setVersionPath(pending.path);
+        const resumedSteps = buildResumedSteps(pending.lastCompletedStep);
+        dispatch({ type: 'RESET', steps: resumedSteps });
+        const lastIdx = pending.lastCompletedStep
+            ? STEP_DEFS.findIndex(s => s.id === pending.lastCompletedStep)
+            : -1;
+        setCurrentStepIndex(lastIdx + 1);
+    };
+    // ── Input hooks ────────────────────────────────────────────────────────────
+    // Input field: Escape = back, ↓ = switch to pending or installed list
+    useInput((_char, key) => {
+        if (key.escape) {
+            onBack();
+            return;
+        }
+        if (key.downArrow) {
+            if (pendingInstalls.length > 0) {
+                setFocus('pending');
+                setPendingSelected(0);
+            }
+            else if (installedVersions.length > 0) {
+                setFocus('installed');
+                setInstalledSelected(0);
+            }
+        }
+    }, { isActive: currentStepIndex === 0 && focus === 'input' });
+    // Pending list navigation
+    useInput((_char, key) => {
+        if (key.escape || (key.upArrow && pendingSelected === 0)) {
+            setFocus('input');
+            return;
+        }
+        if (key.upArrow)
+            setPendingSelected(p => p - 1);
+        if (key.downArrow) {
+            if (pendingSelected < pendingInstalls.length - 1)
+                setPendingSelected(p => p + 1);
+            else if (installedVersions.length > 0) {
+                setFocus('installed');
+                setInstalledSelected(0);
+            }
+        }
+        if (key.return && pendingInstalls[pendingSelected]) {
+            handleResume(pendingInstalls[pendingSelected]);
+        }
+    }, { isActive: currentStepIndex === 0 && focus === 'pending' });
+    // Installed versions navigation
+    useInput((_char, key) => {
+        if (key.escape || (key.upArrow && installedSelected === 0)) {
+            if (pendingInstalls.length > 0) {
+                setFocus('pending');
+                setPendingSelected(pendingInstalls.length - 1);
+            }
+            else
+                setFocus('input');
+            return;
+        }
+        if (key.upArrow)
+            setInstalledSelected(p => p - 1);
+        if (key.downArrow)
+            setInstalledSelected(p => Math.min(p + 1, installedVersions.length - 1));
+        if (key.return && installedVersions[installedSelected]) {
+            handleReinstall(installedVersions[installedSelected]);
+        }
+    }, { isActive: currentStepIndex === 0 && focus === 'installed' });
+    // Error recovery: Relancer / Retour
+    useInput((_char, key) => {
+        if (key.leftArrow)
+            setErrorAction(0);
+        if (key.rightArrow)
+            setErrorAction(1);
+        if (key.escape)
+            onBack();
+        if (key.return)
+            errorAction === 0 ? handleRetry() : onBack();
+    }, { isActive: !!steps.find(s => s.status === 'error') && currentStepIndex > 0 });
+    // Done: wait for Escape before navigating back
+    useInput((_char, key) => { if (key.escape)
+        onCompleteRef.current(); }, { isActive: done });
+    // ── Save progress helper ───────────────────────────────────────────────────
+    const saveProgress = useCallback(async (lastCompletedStep) => {
+        try {
+            const current = await readConfig();
+            await writeConfig({
+                ...current,
+                pending_installs: {
+                    ...(current.pending_installs ?? {}),
+                    [branchNameRef.current]: {
+                        branch: branchNameRef.current,
+                        path: versionPathRef.current,
+                        lastCompletedStep,
+                    },
+                },
+            });
+        }
+        catch { /* non-critical — installation continues regardless */ }
+    }, []);
+    const saveProgressRef = useRef(saveProgress);
+    saveProgressRef.current = saveProgress;
+    // ── Branch input submit ────────────────────────────────────────────────────
+    const handleBranchSubmit = async (value) => {
+        const name = value.trim();
+        if (!name) {
+            setInputError('Le nom de la branche ne peut pas être vide.');
+            return;
+        }
+        if (config.odoo_versions[name]) {
+            const existing = config.odoo_versions[name];
+            if (await dirExists(existing.path)) {
+                setInputError(`La version "${name}" est déjà installée dans ${existing.path}`);
+                return;
+            }
+            // Dossier supprimé manuellement → on nettoie la config et on réinstalle
+            const current = await readConfig();
+            const { [name]: _removed, ...restVersions } = current.odoo_versions;
+            await writeConfig({ ...current, odoo_versions: restVersions });
+        }
+        const path = join(config.odoo_path_repo, name);
+        branchNameRef.current = name;
+        versionPathRef.current = path;
+        setBranchName(name);
+        setVersionPath(path);
+        dispatch({ type: 'SET_STATUS', id: 'branch_input', status: 'success', errorMessage: name });
+        void saveProgressRef.current('branch_input');
+        setCurrentStepIndex(1);
+    };
+    // ── Auto steps ──────────────────────────────────────────────────────────
+    const runCheckCommunity = useCallback(async () => {
+        dispatchRef.current({ type: 'SET_STATUS', id: 'check_community', status: 'running' });
+        const r = await checkBranch(ODOO_COMMUNITY_URL, branchNameRef.current);
+        if (r.ok) {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'check_community', status: 'success' });
+            void saveProgressRef.current('check_community');
+            setCurrentStepIndex(2);
+        }
+        else {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'check_community', status: 'error', errorMessage: r.error });
+        }
+    }, []);
+    const runCheckEnterprise = useCallback(async () => {
+        dispatchRef.current({ type: 'SET_STATUS', id: 'check_enterprise', status: 'running' });
+        const r = await checkBranch(ODOO_ENTERPRISE_URL, branchNameRef.current);
+        if (r.ok) {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'check_enterprise', status: 'success' });
+            void saveProgressRef.current('check_enterprise');
+            setCurrentStepIndex(3);
+        }
+        else {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'check_enterprise', status: 'error', errorMessage: r.error });
+        }
+    }, []);
+    const runCreateDir = useCallback(async () => {
+        dispatchRef.current({ type: 'SET_STATUS', id: 'create_dir', status: 'running' });
+        try {
+            await mkdir(versionPathRef.current, { recursive: true });
+            dispatchRef.current({
+                type: 'SET_STATUS', id: 'create_dir', status: 'success',
+                errorMessage: versionPathRef.current,
+            });
+            void saveProgressRef.current('create_dir');
+            setCurrentStepIndex(4);
+        }
+        catch (err) {
+            dispatchRef.current({
+                type: 'SET_STATUS', id: 'create_dir', status: 'error',
+                errorMessage: err.message,
+            });
+        }
+    }, []);
+    const runCloneCommunity = useCallback(async () => {
+        dispatchRef.current({ type: 'SET_STATUS', id: 'clone_community', status: 'running' });
+        setCloneProgress(null);
+        const dest = join(versionPathRef.current, 'community');
+        if (await dirExists(dest)) {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'clone_community', status: 'success', errorMessage: `${dest} (déjà présent)` });
+            void saveProgressRef.current('clone_community');
+            setCurrentStepIndex(5);
+            return;
+        }
+        let lastUpdate = 0;
+        const r = await cloneRepo(ODOO_COMMUNITY_URL, dest, branchNameRef.current, progress => {
+            const now = Date.now();
+            if (now - lastUpdate >= 80) { // ~12 fps max
+                lastUpdate = now;
+                setCloneProgress(progress);
+            }
+        });
+        setCloneProgress(null);
+        if (r.ok) {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'clone_community', status: 'success', errorMessage: dest });
+            void saveProgressRef.current('clone_community');
+            setCurrentStepIndex(5);
+        }
+        else {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'clone_community', status: 'error', errorMessage: r.error });
+        }
+    }, []);
+    const runCloneEnterprise = useCallback(async () => {
+        dispatchRef.current({ type: 'SET_STATUS', id: 'clone_enterprise', status: 'running' });
+        setCloneProgress(null);
+        const dest = join(versionPathRef.current, 'enterprise');
+        if (await dirExists(dest)) {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'clone_enterprise', status: 'success', errorMessage: `${dest} (déjà présent)` });
+            void saveProgressRef.current('clone_enterprise');
+            setCurrentStepIndex(6);
+            return;
+        }
+        let lastUpdate = 0;
+        const r = await cloneRepo(ODOO_ENTERPRISE_URL, dest, branchNameRef.current, progress => {
+            const now = Date.now();
+            if (now - lastUpdate >= 80) {
+                lastUpdate = now;
+                setCloneProgress(progress);
+            }
+        });
+        setCloneProgress(null);
+        if (r.ok) {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'clone_enterprise', status: 'success', errorMessage: dest });
+            void saveProgressRef.current('clone_enterprise');
+            setCurrentStepIndex(6);
+        }
+        else {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'clone_enterprise', status: 'error', errorMessage: r.error });
+        }
+    }, []);
+    const runCreateVenv = useCallback(async () => {
+        dispatchRef.current({ type: 'SET_STATUS', id: 'create_venv', status: 'running' });
+        const venvPath = join(versionPathRef.current, '.venv');
+        const r = await createVenv(venvPath);
+        if (r.ok) {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'create_venv', status: 'success', errorMessage: venvPath });
+            void saveProgressRef.current('create_venv');
+            setCurrentStepIndex(7);
+        }
+        else {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'create_venv', status: 'error', errorMessage: r.error });
+        }
+    }, []);
+    const runInstallRequirements = useCallback(async () => {
+        dispatchRef.current({ type: 'SET_STATUS', id: 'install_requirements', status: 'running' });
+        setPipOutput('');
+        const pipPath = join(versionPathRef.current, '.venv', 'bin', 'pip');
+        const requirementsPath = join(versionPathRef.current, 'community', 'requirements.txt');
+        const r = await installRequirements(pipPath, requirementsPath, line => {
+            setPipOutput(line);
+        });
+        if (r.ok) {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'install_requirements', status: 'success' });
+            void saveProgressRef.current('install_requirements');
+            setCurrentStepIndex(8);
+        }
+        else {
+            dispatchRef.current({ type: 'SET_STATUS', id: 'install_requirements', status: 'error', errorMessage: r.error });
+        }
+    }, []);
+    const runCreateExtras = useCallback(async () => {
+        dispatchRef.current({ type: 'SET_STATUS', id: 'create_extras', status: 'running' });
+        const base = versionPathRef.current;
+        const branch = branchNameRef.current;
+        try {
+            await mkdir(join(base, 'custom'), { recursive: true });
+            await mkdir(join(base, 'config'), { recursive: true });
+            const current = await readConfig();
+            // Remove from pending_installs and add to odoo_versions atomically
+            const { [branch]: _removed, ...restPending } = current.pending_installs ?? {};
+            await writeConfig({
+                ...current,
+                odoo_versions: { ...current.odoo_versions, [branch]: { branch, path: base } },
+                pending_installs: restPending,
+            });
+            dispatchRef.current({ type: 'SET_STATUS', id: 'create_extras', status: 'success' });
+            setDone(true);
+        }
+        catch (err) {
+            dispatchRef.current({
+                type: 'SET_STATUS', id: 'create_extras', status: 'error',
+                errorMessage: err.message,
+            });
+        }
+    }, []);
+    useEffect(() => {
+        if (currentStepIndex === 0)
+            return;
+        switch (currentStepIndex) {
+            case 1:
+                void runCheckCommunity();
+                break;
+            case 2:
+                void runCheckEnterprise();
+                break;
+            case 3:
+                void runCreateDir();
+                break;
+            case 4:
+                void runCloneCommunity();
+                break;
+            case 5:
+                void runCloneEnterprise();
+                break;
+            case 6:
+                void runCreateVenv();
+                break;
+            case 7:
+                void runInstallRequirements();
+                break;
+            case 8:
+                void runCreateExtras();
+                break;
+        }
+        // retryCount in deps: re-triggers the current step when user retries
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [currentStepIndex, retryCount, runCheckCommunity, runCheckEnterprise, runCreateDir, runCloneCommunity, runCloneEnterprise, runCreateVenv, runInstallRequirements, runCreateExtras]);
+    const isCloneStep = currentStepIndex === 4 || currentStepIndex === 5;
+    const isPipStep = currentStepIndex === 7;
+    const errorStep = steps.find(s => s.status === 'error');
+    const cloneLabel = currentStepIndex === 4 ? 'community' : 'enterprise';
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+        React.createElement(Box, { flexDirection: "row", flexGrow: 1 },
+            React.createElement(LeftPanel, { width: leftWidth, primaryColor: getPrimaryColor(config), textColor: textColor }),
+            React.createElement(Box, { flexGrow: 1, flexDirection: "column", paddingX: 3, paddingY: 2, gap: 1 },
+                React.createElement(Text, { color: getSecondaryColor(config), bold: true }, "Installer une version"),
+                currentStepIndex === 0 && (React.createElement(Box, { flexDirection: "column", gap: 1, marginTop: 1 },
+                    focus === 'input' ? (React.createElement(React.Fragment, null,
+                        React.createElement(Text, { color: "white" }, "Nom de la branche Odoo (ex : 17.0, 16.0) :"),
+                        React.createElement(Box, null,
+                            React.createElement(Text, { color: textColor, dimColor: true }, '› '),
+                            React.createElement(TextInput, { value: branchInput, onChange: v => { setBranchInput(v); setInputError(null); }, onSubmit: handleBranchSubmit, placeholder: "17.0" })),
+                        inputError && React.createElement(Text, { color: "red" }, inputError),
+                        React.createElement(Text, { color: textColor, dimColor: true },
+                            '↵ valider  ·  Échap retour',
+                            pendingInstalls.length > 0 ? '  ·  ↓ reprises' : '',
+                            installedVersions.length > 0 ? '  ·  ↓ installées' : ''))) : (React.createElement(Text, { color: textColor, dimColor: true }, "Nom de la branche Odoo (ex : 17.0, 16.0)")),
+                    pendingInstalls.length > 0 && (React.createElement(Box, { flexDirection: "column", gap: 0, marginTop: 1 },
+                        React.createElement(Text, { color: "yellow", bold: true }, "Installations en cours :"),
+                        pendingInstalls.map((p, i) => {
+                            const isSelected = focus === 'pending' && i === pendingSelected;
+                            const lastIdx = p.lastCompletedStep
+                                ? STEP_DEFS.findIndex(s => s.id === p.lastCompletedStep)
+                                : -1;
+                            const nextStep = STEP_DEFS[lastIdx + 1];
+                            const resumeLabel = nextStep?.label ?? '–';
+                            return (React.createElement(Text, { key: p.branch, color: isSelected ? 'black' : 'white', backgroundColor: isSelected ? 'yellow' : undefined, bold: isSelected },
+                                ` ${isSelected ? '▶' : ' '} ${p.branch}  `,
+                                React.createElement(Text, { color: isSelected ? 'black' : 'gray', dimColor: !isSelected }, `reprendre depuis : ${resumeLabel}`)));
+                        }),
+                        focus === 'pending' && (React.createElement(Text, { color: textColor, dimColor: true }, '↑↓ naviguer  ·  ↵ reprendre  ·  Échap retour')))),
+                    installedVersions.length > 0 && (React.createElement(Box, { flexDirection: "column", gap: 0, marginTop: 1 },
+                        React.createElement(Text, { color: "white", bold: true }, "Versions install\u00E9es :"),
+                        installedVersions.map((v, i) => {
+                            const isSelected = focus === 'installed' && i === installedSelected;
+                            return (React.createElement(Text, { key: v.branch, color: isSelected ? 'black' : 'white', backgroundColor: isSelected ? cursorColor : undefined, bold: isSelected },
+                                ` ${isSelected ? '▶' : ' '} ${v.branch}  `,
+                                React.createElement(Text, { color: isSelected ? 'black' : 'gray', dimColor: !isSelected }, v.path)));
+                        }),
+                        focus === 'installed' && (React.createElement(Text, { color: textColor, dimColor: true }, '↑↓ naviguer  ·  ↵ relancer  ·  Échap retour')))))),
+                currentStepIndex > 0 && !isCloneStep && !done && !errorStep && (React.createElement(Box, { marginTop: 1, flexDirection: "column", gap: 0 },
+                    React.createElement(Text, { color: textColor },
+                        'Installation de ',
+                        React.createElement(Text, { color: getPrimaryColor(config), bold: true }, branchName),
+                        '…'),
+                    isPipStep && pipOutput !== '' && (React.createElement(Text, { color: textColor, dimColor: true }, pipOutput)))),
+                errorStep && currentStepIndex > 0 && (React.createElement(Box, { flexDirection: "column", gap: 1, marginTop: 1 },
+                    React.createElement(Box, { flexDirection: "row", gap: 2 },
+                        React.createElement(Text, { color: errorAction === 0 ? 'black' : 'white', backgroundColor: errorAction === 0 ? cursorColor : undefined, bold: errorAction === 0 }, ' ↺ Relancer '),
+                        React.createElement(Text, { color: errorAction === 1 ? 'black' : 'white', backgroundColor: errorAction === 1 ? 'gray' : undefined, bold: errorAction === 1 }, ' ← Retour ')),
+                    React.createElement(Text, { color: textColor, dimColor: true }, '◀▶ choisir  ·  ↵ confirmer  ·  Échap retour'))),
+                isCloneStep && !errorStep && (React.createElement(Box, { flexDirection: "column", marginTop: 1, gap: 0 },
+                    React.createElement(Text, { color: textColor },
+                        'Clonage ',
+                        React.createElement(Text, { color: getPrimaryColor(config), bold: true }, cloneLabel),
+                        ` → ${join(versionPath, cloneLabel)}`),
+                    React.createElement(Box, { marginTop: 1, flexDirection: "column", gap: 0 }, cloneProgress ? (React.createElement(React.Fragment, null,
+                        React.createElement(ProgressBar, { percent: cloneProgress.percent, textColor: textColor }),
+                        React.createElement(Box, { gap: 2, marginTop: 0 },
+                            React.createElement(Text, { color: textColor, dimColor: true }, PHASE_LABEL[cloneProgress.phase]),
+                            cloneProgress.speed && (React.createElement(Text, { color: getPrimaryColor(config), dimColor: true }, cloneProgress.speed))))) : (React.createElement(Text, { color: textColor, dimColor: true }, "\u27F3 Connexion au d\u00E9p\u00F4t\u2026"))))),
+                done && (React.createElement(Box, { flexDirection: "column", marginTop: 1, gap: 1 },
+                    React.createElement(Text, { color: "green" },
+                        '✓ ',
+                        React.createElement(Text, { bold: true }, branchName),
+                        ' installé avec succès.'),
+                    React.createElement(Box, { flexDirection: "column", gap: 0 },
+                        React.createElement(Text, { color: textColor, dimColor: true }, `  community/  → ${join(versionPath, 'community')}`),
+                        React.createElement(Text, { color: textColor, dimColor: true }, `  enterprise/ → ${join(versionPath, 'enterprise')}`),
+                        React.createElement(Text, { color: textColor, dimColor: true }, `  .venv/      → ${join(versionPath, '.venv')}`),
+                        React.createElement(Text, { color: textColor, dimColor: true }, `  custom/`),
+                        React.createElement(Text, { color: textColor, dimColor: true }, `  config/`)),
+                    React.createElement(Text, { color: "white" }, 'Échap retour'))))),
+        React.createElement(StepsPanel, { steps: steps, textColor: textColor }),
+        React.createElement(ErrorPanel, { steps: steps })));
+}

package/dist/screens/OdooScreen.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { NupoConfig, OdooServiceConfig, CliStartArgs } from '../types/index.js';
+interface OdooScreenProps {
+    leftWidth: number;
+    config: NupoConfig;
+    onBack: () => void;
+    onConfigChange: () => void;
+    onServiceRunning: (service: OdooServiceConfig) => void;
+    onServiceStopped: () => void;
+    autoStart?: CliStartArgs;
+}
+export declare function OdooScreen({ leftWidth, config, onBack, onConfigChange, onServiceRunning, onServiceStopped, autoStart }: OdooScreenProps): React.JSX.Element;
+export {};

package/dist/screens/OdooScreen.js

@@ -0,0 +1,76 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { getPrimaryColor, getSecondaryColor, getTextColor, getCursorColor } from '../types/index.js';
+import { LeftPanel } from '../components/LeftPanel.js';
+import { InstallVersionScreen } from './InstallVersionScreen.js';
+import { UpgradeVersionScreen } from './UpgradeVersionScreen.js';
+import { OdooServiceScreen } from './OdooServiceScreen.js';
+import { StartServiceScreen } from './StartServiceScreen.js';
+const ODOO_OPTIONS = [
+    {
+        id: 'install',
+        label: 'Installer une version',
+        description: "Installer une nouvelle version d'Odoo : télécharge community et enterprise avec --depth 1.",
+    },
+    {
+        id: 'upgrade',
+        label: 'Mise à niveau',
+        description: "Mettre à jour une version Odoo installée : récupère les derniers commits de community et enterprise.",
+    },
+    {
+        id: 'service',
+        label: 'Configurer Service Odoo',
+        description: "Créer ou modifier un fichier de configuration .conf pour démarrer un service Odoo.",
+    },
+    {
+        id: 'start',
+        label: 'Démarrer Service Odoo',
+        description: "Lancer un service Odoo configuré avec des arguments supplémentaires optionnels.",
+    },
+];
+export function OdooScreen({ leftWidth, config, onBack, onConfigChange, onServiceRunning, onServiceStopped, autoStart }) {
+    const [subScreen, setSubScreen] = useState(null);
+    const [selected, setSelected] = useState(0);
+    const textColor = getTextColor(config);
+    const cursorColor = getCursorColor(config);
+    // Auto-navigate to start screen when CLI args are present
+    useEffect(() => {
+        if (autoStart)
+            setSubScreen('start');
+    }, []);
+    useInput((_char, key) => {
+        if (key.upArrow)
+            setSelected(prev => (prev - 1 + ODOO_OPTIONS.length) % ODOO_OPTIONS.length);
+        if (key.downArrow)
+            setSelected(prev => (prev + 1) % ODOO_OPTIONS.length);
+        if (key.return)
+            setSubScreen(ODOO_OPTIONS[selected].id);
+        if (key.escape)
+            onBack();
+    }, { isActive: subScreen === null });
+    if (subScreen === 'install') {
+        return (React.createElement(InstallVersionScreen, { config: config, leftWidth: leftWidth, onComplete: () => { onConfigChange(); setSubScreen(null); }, onBack: () => setSubScreen(null) }));
+    }
+    if (subScreen === 'upgrade') {
+        return (React.createElement(UpgradeVersionScreen, { config: config, leftWidth: leftWidth, onBack: () => setSubScreen(null) }));
+    }
+    if (subScreen === 'service') {
+        return (React.createElement(OdooServiceScreen, { config: config, leftWidth: leftWidth, onBack: () => setSubScreen(null), onConfigChange: () => { onConfigChange(); setSubScreen(null); } }));
+    }
+    if (subScreen === 'start') {
+        return (React.createElement(StartServiceScreen, { config: config, leftWidth: leftWidth, onBack: () => setSubScreen(null), onServiceRunning: onServiceRunning, onServiceStopped: onServiceStopped, autoStart: autoStart }));
+    }
+    const current = ODOO_OPTIONS[selected];
+    return (React.createElement(Box, { flexDirection: "row" },
+        React.createElement(LeftPanel, { width: leftWidth, primaryColor: getPrimaryColor(config), textColor: textColor }),
+        React.createElement(Box, { flexGrow: 1, flexDirection: "column", paddingX: 3, paddingY: 2, gap: 1 },
+            React.createElement(Text, { color: getSecondaryColor(config), bold: true }, "Odoo"),
+            React.createElement(Box, { flexDirection: "column", gap: 0 }, ODOO_OPTIONS.map((opt, i) => {
+                const isSelected = i === selected;
+                return (React.createElement(Text, { key: opt.id, color: isSelected ? 'black' : 'white', backgroundColor: isSelected ? cursorColor : undefined, bold: isSelected }, ` ${isSelected ? '▶' : ' '} ${opt.label}`));
+            })),
+            React.createElement(Box, { borderStyle: "round", borderColor: textColor, paddingX: 1, paddingY: 0 },
+                React.createElement(Text, { color: textColor, wrap: "wrap" }, current.description)),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: textColor, dimColor: true }, '↑↓ naviguer  ·  ↵ sélectionner  ·  Échap retour')))));
+}

package/dist/screens/OdooServiceScreen.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { NupoConfig } from '../types/index.js';
+interface OdooServiceScreenProps {
+    config: NupoConfig;
+    leftWidth: number;
+    onBack: () => void;
+    onConfigChange: () => void;
+}
+export declare function OdooServiceScreen({ config, leftWidth, onBack, onConfigChange }: OdooServiceScreenProps): React.JSX.Element;
+export {};

package/dist/screens/OdooServiceScreen.js

@@ -0,0 +1,51 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { getPrimaryColor, getSecondaryColor, getTextColor, getCursorColor } from '../types/index.js';
+import { LeftPanel } from '../components/LeftPanel.js';
+import { ConfigureServiceScreen } from './ConfigureServiceScreen.js';
+export function OdooServiceScreen({ config, leftWidth, onBack, onConfigChange }) {
+    const services = Object.values(config.odoo_services ?? {});
+    const textColor = getTextColor(config);
+    const cursorColor = getCursorColor(config);
+    const itemCount = 1 + services.length; // 0 = nouveau, 1..n = services
+    const [selected, setSelected] = useState(0);
+    const [subScreen, setSubScreen] = useState(null);
+    useInput((_char, key) => {
+        if (key.escape) {
+            onBack();
+            return;
+        }
+        if (key.upArrow)
+            setSelected(p => (p - 1 + itemCount) % itemCount);
+        if (key.downArrow)
+            setSelected(p => (p + 1) % itemCount);
+        if (key.return) {
+            if (selected === 0)
+                setSubScreen('new');
+            else
+                setSubScreen(services[selected - 1]);
+        }
+    }, { isActive: subScreen === null });
+    if (subScreen !== null) {
+        return (React.createElement(ConfigureServiceScreen, { config: config, leftWidth: leftWidth, initialService: subScreen === 'new' ? undefined : subScreen, onComplete: () => { onConfigChange(); setSubScreen(null); }, onBack: () => setSubScreen(null) }));
+    }
+    return (React.createElement(Box, { flexDirection: "row", flexGrow: 1 },
+        React.createElement(LeftPanel, { width: leftWidth, primaryColor: getPrimaryColor(config), textColor: textColor }),
+        React.createElement(Box, { flexGrow: 1, flexDirection: "column", paddingX: 3, paddingY: 2, gap: 1 },
+            React.createElement(Text, { color: getSecondaryColor(config), bold: true }, "Configurer Service Odoo"),
+            React.createElement(Box, { flexDirection: "column", marginTop: 1, gap: 0 },
+                React.createElement(Text, { color: selected === 0 ? 'black' : 'cyan', backgroundColor: selected === 0 ? cursorColor : undefined, bold: selected === 0 }, ` ${selected === 0 ? '▶' : ' '} + Nouveau service`),
+                services.length > 0 && (React.createElement(Text, { color: textColor, dimColor: true }, '  ─────────────────')),
+                services.length === 0 && (React.createElement(Text, { color: textColor, dimColor: true }, '  Aucun service configuré')),
+                services.map((s, i) => {
+                    const isSel = i + 1 === selected;
+                    return (React.createElement(Text, { key: s.name, color: isSel ? 'black' : 'white', backgroundColor: isSel ? cursorColor : undefined, bold: isSel },
+                        ` ${isSel ? '▶' : ' '} ${s.name}  `,
+                        React.createElement(Text, { color: isSel ? 'black' : 'gray', dimColor: !isSel },
+                            s.branch,
+                            s.useEnterprise ? '  · Enterprise' : '',
+                            s.customFolders.length > 0 ? `  · ${s.customFolders.length} module(s)` : '')));
+                })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: textColor, dimColor: true }, '↑↓ naviguer  ·  ↵ sélectionner  ·  Échap retour')))));
+}

package/dist/screens/StartServiceScreen.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { NupoConfig, OdooServiceConfig, CliStartArgs } from '../types/index.js';
+interface StartServiceScreenProps {
+    config: NupoConfig;
+    leftWidth: number;
+    onBack: () => void;
+    onServiceRunning: (service: OdooServiceConfig) => void;
+    onServiceStopped: () => void;
+    autoStart?: CliStartArgs;
+}
+export declare function StartServiceScreen({ config, leftWidth, onBack, onServiceRunning, onServiceStopped, autoStart, }: StartServiceScreenProps): React.JSX.Element;
+export {};