@wpmoo/toolkit 0.9.4 → 0.9.6

package/dist/cli.js

@@ -2,26 +2,32 @@
 import { realpathSync } from 'node:fs';
 import { rm, rename } from 'node:fs/promises';
 import { basename, relative, resolve } from 'node:path';
+import { emitKeypressEvents } from 'node:readline';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { commandFromArgs, isHelpRequested, isVersionRequested, optionsFromArgs, parseArgs, stripInternalFlags, } from './args.js';
+import { cockpitCommands } from './cockpit/command-registry.js';
 import { collectDailyActionArgs } from './cockpit/daily-prompts.js';
+import { selectModuleAction } from './cockpit/module-action-menu.js';
+import { selectModuleFromBrowser } from './cockpit/module-browser.js';
 import { selectCockpitTopLevelMenu } from './cockpit/menu.js';
 import { confirmCockpitCommandRisk } from './cockpit/safety.js';
 import { detectDevelopmentEnvironment } from './environment.js';
 import { commandOdooVersion } from './environment-version.js';
 import { defaultAgentSkillsTemplateUrl } from './external-templates.js';
-import { isDailyActionCommand, runDailyAction } from './daily-actions.js';
+import { listEnvironmentDatabases } from './databases.js';
+import { isDailyActionCommand, runDailyAction, runDailyActionWithStyledOutput } from './daily-actions.js';
 import { getDoctorReport, runDoctor } from './doctor.js';
 import { getOriginUrl, realGit } from './git.js';
 import { renderHelp } from './help.js';
 import { runLocalCockpit } from './local-cockpit.js';
-import { addModuleToSourceRepo, listModulesInSourceRepo, removeModuleFromSourceRepo, } from './module-actions.js';
+import { addModuleToSourceRepo, removeModuleFromSourceRepo, } from './module-actions.js';
 import { supportedOdooVersions } from './odoo-versions.js';
 import { renderRepositorySetupNote } from './prompt-copy.js';
 import { promptRepositoryUrl } from './prompt-repositories.js';
 import { inferGitHubOwner, inferRepoPath, normalizeRepositoryUrl } from './repo-url.js';
 import { addModuleRepo, listModuleRepos, removeModuleRepo } from './repo-actions.js';
 import { renderSafeResetPreview, safeResetEnvironment } from './safe-reset.js';
+import { getServiceRuntimeStatus, renderServiceRuntimeStatusLine, } from './service-runtime-status.js';
 import { listSources, renderSourceList, sourceListJson, sourceSyncJson, syncSources, } from './source-actions.js';
 import { backupTargetPath, expectedTargetConfirmation, inspectEnvironmentTarget, renderExistingEnvironmentSummary, renderForeignEnvironmentTargetWarning, } from './environment-target-preflight.js';
 import { getGitHubPrerequisiteStatus, renderGitHubPrerequisiteGuidance, } from './github-prerequisites.js';
@@ -195,17 +201,39 @@ function renderStartupBanner(details, latestVersion) {
     const versionLine = startupVersionLine(latestVersion);
     return renderBanner(details?.(versionLine), details ? { version: versionLine } : undefined);
 }
-function renderCockpitStatusLines(status, lastStatus) {
-    return [renderStartupEnvironmentLine(status), lastStatus];
+function renderCockpitStatusLines(status, serviceStatus, lastStatus) {
+    return [renderStartupEnvironmentLine(status), renderServiceRuntimeStatusLine(serviceStatus), lastStatus];
 }
 function renderLastCommandStatus(command) {
     return `Last: ${command.label} ✓ completed`;
 }
+function renderLastCommandError(command, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `Last: ${command.label} ✗ Error: ${message}`;
+}
 function clearCockpitScreen() {
     if (process.stdout.isTTY) {
         process.stdout.write('\u001B[2J\u001B[H');
     }
 }
+const ANSI_ACTION = '\u001B[38;2;226;184;96m';
+const ANSI_SUCCESS = '\u001B[32m';
+const ANSI_DEFAULT_FOREGROUND = '\u001B[39m';
+const ANSI_DIM_INFO = '\u001B[2m\u001B[38;2;120;157;181m';
+const ANSI_RESET = '\u001B[0m';
+function renderActionText(value) {
+    return ansi(value, ANSI_ACTION, ANSI_DEFAULT_FOREGROUND);
+}
+function renderCompletedText(action) {
+    if (!supportsAnsi()) {
+        return `✓ ${action} completed.`;
+    }
+    return `${ANSI_SUCCESS}✓${ANSI_DEFAULT_FOREGROUND} ${action} ${ANSI_SUCCESS}completed${ANSI_DEFAULT_FOREGROUND}.`;
+}
+function renderBackHelp() {
+    return ansi('Esc to go back', ANSI_DIM_INFO, ANSI_RESET);
+}
+const manualDatabaseValue = '__wpmoo_manual_database_entry__';
 async function showStartup(argv, skipUpdateCheck, details) {
     if (skipUpdateCheck) {
         console.log(renderStartupBanner(details));
@@ -245,8 +273,8 @@ async function showStartup(argv, skipUpdateCheck, details) {
     }
     console.log();
 }
-async function selectCockpitCommandFromMenu() {
-    const selection = await selectCockpitTopLevelMenu();
+async function selectCockpitCommandFromMenu(serviceStatus) {
+    const selection = await selectCockpitTopLevelMenu({ serviceStatus });
     if (selection.kind === 'exit') {
         return 'exit';
     }
@@ -598,9 +626,6 @@ async function selectSourceRepo(target, cancelAction = 'exit') {
     }
     return { repoPath: String(selected), sourceType: 'private' };
 }
-function formatSourceRepoPromptPath(target, selected) {
-    return renderedSourceRepoPath(target, selected.sourceType, selected.repoPath);
-}
 function suggestedModuleName(repoPath) {
     return 'odoo_sample_module';
 }
@@ -796,23 +821,18 @@ function removeModuleOptionsFromArgs(argv) {
     };
 }
 async function removeModuleOptionsFromPrompts(showIntro = true, cancelAction = 'exit') {
-    showSubmenuIntro('Remove module from source repo', showIntro, cancelAction);
+    if (showIntro) {
+        introPrompt('Remove module');
+    }
     const target = process.cwd();
-    const sourceRepo = await selectSourceRepo(target, cancelAction);
-    const modules = await listModulesInSourceRepo(target, sourceRepo.repoPath, sourceRepo.sourceType);
-    if (modules.length === 0) {
+    const selectedModule = await selectModuleFromBrowser(target, { cancelAction });
+    if (!selectedModule) {
         if (cancelAction === 'back') {
-            notePrompt(`No Odoo modules found under ${formatSourceRepoPromptPath(target, sourceRepo)}.\nNext: choose "Add module to source repo" first.`, 'Nothing to remove');
+            notePrompt('No Odoo modules found.\nNext: choose "Add module" or "Add source repo" first.', 'Nothing to remove');
             handleUnavailableMenuChoice(cancelAction);
         }
-        throw new Error(`No Odoo modules found under ${formatSourceRepoPromptPath(target, sourceRepo)}`);
+        throw new Error('No Odoo modules found');
     }
-    const moduleName = await selectPrompt({
-        message: menuPromptMessage('Module to remove', cancelAction),
-        options: modules.map((module) => ({ value: module, label: module })),
-        initialValue: modules[0],
-    });
-    handleCancel(moduleName, cancelAction);
     const deleteFiles = await confirmPrompt({
         message: menuPromptMessage('Delete module files too? (y/N)', cancelAction),
         active: 'Y',
@@ -822,9 +842,9 @@ async function removeModuleOptionsFromPrompts(showIntro = true, cancelAction = '
     handleCancel(deleteFiles, cancelAction);
     return {
         target,
-        repoPath: sourceRepo.repoPath,
-        sourceType: sourceRepo.sourceType,
-        moduleName: String(moduleName),
+        repoPath: selectedModule.repoPath,
+        sourceType: selectedModule.sourceType,
+        moduleName: selectedModule.moduleName,
         deleteFiles: Boolean(deleteFiles),
         stage: true,
     };
@@ -963,18 +983,327 @@ async function finishCreateFlow(result, cwd, interactive) {
     }
     outroPrompt(`Created Odoo dev overlay in ${options.target}. Review staged changes, then commit.`);
 }
-async function runCockpitCommand(command, cwd) {
-    if (command.id === 'exit') {
-        return 'exit';
+function selectedModuleRemovalOptions(module, cwd, deleteFiles) {
+    return {
+        target: cwd,
+        repoPath: module.repoPath,
+        sourceType: module.sourceType,
+        moduleName: module.moduleName,
+        deleteFiles,
+        stage: true,
+    };
+}
+function moduleDailyAction(action) {
+    if (action === 'update')
+        return 'update';
+    if (action === 'test')
+        return 'test';
+    if (action === 'lint')
+        return 'lint';
+    return undefined;
+}
+function moduleDailyActionArgs(action, module) {
+    if (action === 'update' || action === 'test') {
+        return [module.moduleName];
     }
-    if (command.target.kind === 'daily') {
-        const argv = await collectDailyActionArgs(command.target.command, cwd);
+    return [];
+}
+function moduleActionTitle(action) {
+    if (action === 'update')
+        return 'Update module';
+    if (action === 'test')
+        return 'Test module';
+    if (action === 'lint')
+        return 'Run lint';
+    if (action === 'delete')
+        return 'Delete module';
+    return 'Module action';
+}
+function moduleActionCompletedLabel(action) {
+    if (action === 'update')
+        return 'Update';
+    if (action === 'test')
+        return 'Test';
+    if (action === 'lint')
+        return 'Lint';
+    return 'Action';
+}
+function commandActionTitle(command) {
+    if (command === 'update')
+        return 'Update module';
+    if (command === 'test')
+        return 'Test module';
+    if (command === 'lint')
+        return 'Run lint';
+    if (command === 'pot')
+        return 'Generate POT';
+    return command;
+}
+function commandCompletedLabel(command) {
+    if (command === 'install')
+        return 'Install';
+    if (command === 'update')
+        return 'Update';
+    if (command === 'test')
+        return 'Test';
+    if (command === 'lint')
+        return 'Lint';
+    if (command === 'pot')
+        return 'Generate POT';
+    return command;
+}
+function shouldReturnToDailySelection(command) {
+    return ['install', 'update', 'test', 'pot'].includes(command);
+}
+function shouldUseModuleBrowserForDailySelection(command) {
+    return ['update', 'test', 'lint', 'pot'].includes(command);
+}
+function dailyActionSelectedLabel(command, argv) {
+    if (['install', 'update', 'test', 'pot'].includes(command)) {
+        return argv[0];
+    }
+    return undefined;
+}
+async function selectDatabaseArg(cwd, message, fallback, options = {}) {
+    const databases = await listEnvironmentDatabases(cwd, options);
+    if (databases.length > 0) {
+        const selected = await selectPrompt({
+            message: menuPromptMessage(message, 'back'),
+            options: [
+                ...databases.map((database) => ({ value: database, label: database })),
+                { value: manualDatabaseValue, label: 'Manual entry' },
+            ],
+            initialValue: databases.includes(fallback) ? fallback : databases[0],
+        });
+        handleCancel(selected, 'back');
+        if (selected !== manualDatabaseValue) {
+            return String(selected);
+        }
+    }
+    return asString(await textPrompt({
+        message: menuPromptMessage(message, 'back'),
+        defaultValue: fallback,
+        placeholder: fallback,
+    }), fallback, 'back');
+}
+async function collectCockpitModuleDailyActionArgs(command, module, cwd) {
+    const moduleName = module.moduleName;
+    if (command === 'update') {
+        return [moduleName];
+    }
+    if (command === 'test') {
+        return [moduleName];
+    }
+    if (command === 'lint') {
+        return [];
+    }
+    if (command === 'pot') {
+        return [moduleName];
+    }
+    throw new Error(`Unsupported module action command: ${command}`);
+}
+async function renderDailyActionResultPageHeader(title, selectedLabel, cwd) {
+    await renderCockpitSubmenuPage(title, cwd);
+    if (selectedLabel) {
+        console.log(renderActionText(selectedLabel));
+        console.log('');
+    }
+}
+async function renderCockpitSubmenuPage(title, cwd) {
+    const status = await getEnvironmentStatus(cwd);
+    const serviceStatus = await getServiceRuntimeStatus(cwd, status);
+    clearCockpitScreen();
+    console.log(renderBanner(renderCockpitStatusLines(status, serviceStatus, `Last: ${title}`), { version: startupVersionLine() }));
+    console.log();
+    introPrompt(title);
+}
+async function waitForModuleActionBack() {
+    console.log(renderBackHelp());
+    if (!process.stdin.isTTY) {
+        return false;
+    }
+    await new Promise((resolve) => {
+        emitKeypressEvents(process.stdin);
+        const input = process.stdin;
+        const wasRaw = input.isRaw;
+        const listener = (_value, key) => {
+            if (key.ctrl && key.name === 'c') {
+                process.exit(1);
+            }
+            if (key.name === 'escape' || key.sequence === '\u001B') {
+                cleanup();
+                resolve();
+            }
+        };
+        const cleanup = () => {
+            input.off('keypress', listener);
+            if (typeof input.setRawMode === 'function') {
+                input.setRawMode(Boolean(wasRaw));
+            }
+            input.pause();
+        };
+        if (typeof input.setRawMode === 'function') {
+            input.setRawMode(true);
+        }
+        input.resume();
+        input.on('keypress', listener);
+    });
+    return true;
+}
+async function runDailyActionResultPage(command, argv, cwd, title = commandActionTitle(command), selectedLabel = dailyActionSelectedLabel(command, argv), completedLabel = commandCompletedLabel(command)) {
+    await renderDailyActionResultPageHeader(title, selectedLabel, cwd);
+    try {
+        await runDailyActionWithStyledOutput(command, argv, cwd);
+        notePrompt(renderCompletedText(completedLabel), 'Done');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        notePrompt(message, 'Error');
+        await waitForModuleActionBack();
+        throw error;
+    }
+    return waitForModuleActionBack();
+}
+async function runSelectedModuleDailyAction(action, module, cwd) {
+    const command = moduleDailyAction(action);
+    if (!command) {
+        return false;
+    }
+    return runDailyActionResultPage(command, moduleDailyActionArgs(action, module), cwd, moduleActionTitle(action), module.moduleName, moduleActionCompletedLabel(action));
+}
+async function runSelectedModuleAction(action, module, cwd) {
+    if (action === 'delete') {
+        const deleteFiles = await confirmPrompt({
+            message: menuPromptMessage('Delete module files too? (y/N)', 'back'),
+            active: 'Y',
+            inactive: 'n',
+            initialValue: false,
+        });
+        handleCancel(deleteFiles, 'back');
+        const removeCommand = cockpitCommands.find((entry) => entry.id === 'remove-module');
+        if (removeCommand && !(await confirmCockpitCommandRisk(removeCommand))) {
+            notePrompt(`Module ${module.moduleName} was not removed.`, 'Action skipped');
+            return false;
+        }
+        await removeModuleFromSourceRepo(selectedModuleRemovalOptions(module, cwd, Boolean(deleteFiles)));
+        notePrompt(`Removed module ${module.moduleName} from source repo ${module.repoPath}.`, 'Done');
+        return false;
+    }
+    return runSelectedModuleDailyAction(action, module, cwd);
+}
+async function runCockpitModuleDailyCommand(command, cwd) {
+    if (command.target.kind !== 'daily') {
+        return;
+    }
+    const dailyCommand = command.target.command;
+    while (true) {
+        let selectedModule;
+        let argv;
+        try {
+            await renderCockpitSubmenuPage(command.label, cwd);
+            const module = await selectModuleFromBrowser(cwd);
+            if (!module) {
+                notePrompt('No Odoo modules found.\nNext: choose "Add module" or "Add source repo" first.', command.label);
+                return;
+            }
+            selectedModule = module;
+            argv = await collectCockpitModuleDailyActionArgs(dailyCommand, selectedModule, cwd);
+        }
+        catch (error) {
+            if (isMenuBackSignal(error)) {
+                return;
+            }
+            throw error;
+        }
         if (!(await confirmCockpitCommandRisk(command))) {
             notePrompt(`${command.slashAlias} was not run.`, 'Action skipped');
-            return 'continue';
+            return;
+        }
+        const returnedByBack = await runDailyActionResultPage(dailyCommand, argv, cwd, command.label, selectedModule.moduleName, commandCompletedLabel(dailyCommand));
+        if (!returnedByBack) {
+            return;
         }
-        await runDailyAction(command.target.command, argv, cwd);
+    }
+}
+async function runCockpitDailyCommand(command, cwd) {
+    if (command.target.kind !== 'daily') {
+        return;
+    }
+    const dailyCommand = command.target.command;
+    if (shouldUseModuleBrowserForDailySelection(dailyCommand)) {
+        await runCockpitModuleDailyCommand(command, cwd);
+        return;
+    }
+    if (!shouldReturnToDailySelection(dailyCommand)) {
+        const argv = await collectDailyActionArgs(dailyCommand, cwd);
+        if (!(await confirmCockpitCommandRisk(command))) {
+            notePrompt(`${command.slashAlias} was not run.`, 'Action skipped');
+            return;
+        }
+        await runDailyAction(dailyCommand, argv, cwd);
         notePrompt(`${command.slashAlias} completed.`, 'Done');
+        return;
+    }
+    while (true) {
+        let argv;
+        try {
+            await renderCockpitSubmenuPage(command.label, cwd);
+            argv = await collectDailyActionArgs(dailyCommand, cwd);
+        }
+        catch (error) {
+            if (isMenuBackSignal(error)) {
+                return;
+            }
+            throw error;
+        }
+        if (!(await confirmCockpitCommandRisk(command))) {
+            notePrompt(`${command.slashAlias} was not run.`, 'Action skipped');
+            return;
+        }
+        const returnedByBack = await runDailyActionResultPage(dailyCommand, argv, cwd, command.label);
+        if (!returnedByBack) {
+            return;
+        }
+    }
+}
+async function runListModulesCommand(cwd) {
+    while (true) {
+        await renderCockpitSubmenuPage('List modules', cwd);
+        const selectedModule = await selectModuleFromBrowser(cwd);
+        if (!selectedModule) {
+            notePrompt('No Odoo modules found.\nNext: choose "Add module" or "Add source repo" first.', 'List modules');
+            return;
+        }
+        while (true) {
+            let moduleAction;
+            try {
+                await renderCockpitSubmenuPage('List modules', cwd);
+                console.log(renderActionText(selectedModule.moduleName));
+                console.log('');
+                moduleAction = await selectModuleAction(selectedModule);
+            }
+            catch (error) {
+                if (isMenuBackSignal(error)) {
+                    break;
+                }
+                throw error;
+            }
+            if (!moduleAction) {
+                break;
+            }
+            const returnedByBack = await runSelectedModuleAction(moduleAction, selectedModule, cwd);
+            if (!returnedByBack) {
+                return;
+            }
+        }
+    }
+}
+async function runCockpitCommand(command, cwd) {
+    if (command.id === 'exit') {
+        return 'exit';
+    }
+    if (command.target.kind === 'daily') {
+        await runCockpitDailyCommand(command, cwd);
         return 'continue';
     }
     if (command.id === 'status') {
@@ -985,6 +1314,10 @@ async function runCockpitCommand(command, cwd) {
         notePrompt(await runDoctor(cwd), 'Doctor');
         return 'continue';
     }
+    if (command.id === 'list-modules') {
+        await runListModulesCommand(cwd);
+        return 'continue';
+    }
     if (command.id === 'add-repo') {
         const options = await addRepoOptionsFromPrompts(false, 'back');
         await ensureAddRepoGitHubRepository(options, 'back');
@@ -1009,7 +1342,7 @@ async function runCockpitCommand(command, cwd) {
         return 'continue';
     }
     if (command.id === 'remove-module') {
-        const options = await removeModuleOptionsFromPrompts(false, 'back');
+        const options = await removeModuleOptionsFromPrompts(true, 'back');
         if (!(await confirmCockpitCommandRisk(command))) {
             notePrompt(`Module ${options.moduleName} was not removed.`, 'Action skipped');
             return 'continue';
@@ -1050,23 +1383,42 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
             return;
         }
         let lastStatus = 'Last: Ready';
-        const initialStatus = await getEnvironmentStatus(cwd);
-        await showStartup(argv, skipUpdateCheck, () => renderCockpitStatusLines(initialStatus, lastStatus));
+        let status = await getEnvironmentStatus(cwd);
+        let serviceStatus = await getServiceRuntimeStatus(cwd, status);
+        await showStartup(argv, skipUpdateCheck, () => renderCockpitStatusLines(status, serviceStatus, lastStatus));
+        const renderCockpitMenuShell = () => {
+            clearCockpitScreen();
+            console.log(renderBanner(renderCockpitStatusLines(status, serviceStatus, lastStatus), { version: startupVersionLine() }));
+            console.log();
+        };
         while (true) {
             try {
-                const command = await selectCockpitCommandFromMenu();
+                const command = await selectCockpitCommandFromMenu(serviceStatus);
                 if (command === 'exit') {
                     return;
                 }
-                const outcome = await runCockpitCommand(command, cwd);
+                let outcome = 'continue';
+                let commandFailed = false;
+                try {
+                    outcome = await runCockpitCommand(command, cwd);
+                }
+                catch (error) {
+                    if (isMenuBackSignal(error)) {
+                        renderCockpitMenuShell();
+                        continue;
+                    }
+                    commandFailed = true;
+                    lastStatus = renderLastCommandError(command, error);
+                }
                 if (outcome === 'exit') {
                     return;
                 }
-                lastStatus = renderLastCommandStatus(command);
-                const status = await getEnvironmentStatus(cwd);
-                clearCockpitScreen();
-                console.log(renderBanner(renderCockpitStatusLines(status, lastStatus), { version: startupVersionLine() }));
-                console.log();
+                if (!commandFailed) {
+                    lastStatus = renderLastCommandStatus(command);
+                }
+                status = await getEnvironmentStatus(cwd);
+                serviceStatus = await getServiceRuntimeStatus(cwd, status);
+                renderCockpitMenuShell();
             }
             catch (error) {
                 if (isMenuBackSignal(error)) {

package/dist/cockpit/command-registry.js

@@ -34,6 +34,10 @@ export const cockpitCommands = [
     dailyCommand('restart', 'services', 'Restart services', 'Restart the Odoo development services.', ['reload']),
     dailyCommand('logs', 'services', 'View logs', 'Stream logs for an Odoo environment service.', ['log', 'tail']),
     dailyCommand('shell', 'services', 'Open shell', 'Open a shell inside the Odoo service container.', ['bash', 'terminal']),
+    internalCommand('list-modules', 'modules', 'List modules', 'Browse detected Odoo modules by source category.', [
+        'modules list',
+        'browse modules',
+    ]),
     dailyCommand('install', 'modules', 'Install module', 'Install one or more Odoo modules into a database.', ['install module']),
     dailyCommand('update', 'modules', 'Update module', 'Update one or more Odoo modules in a database.', ['upgrade']),
     dailyCommand('test', 'modules', 'Run tests', 'Run Odoo tests for one or more modules.', ['tests', 'pytest']),

package/dist/cockpit/daily-prompts.js

@@ -1,9 +1,11 @@
+import { listEnvironmentDatabases } from '../databases.js';
 import { listModulesInSourceRepo } from '../module-actions.js';
 import { listModuleRepos } from '../repo-actions.js';
 import { listSources } from '../source-actions.js';
 import { handlePromptCancel, menuPromptMessage, } from '../menu-navigation.js';
 import { isPromptCancel, selectPrompt, textPrompt } from '../prompts/index.js';
 const manualModuleValue = '__wpmoo_manual_module_entry__';
+const manualDatabaseValue = '__wpmoo_manual_database_entry__';
 function defaultCancelHandler(value, action) {
     handlePromptCancel(isPromptCancel(value), action);
 }
@@ -12,6 +14,7 @@ function promptDeps(deps = {}) {
         select: deps.select ?? ((options) => selectPrompt(options)),
         text: deps.text ?? ((options) => textPrompt(options)),
         list: deps.list ?? ((options) => selectPrompt(options)),
+        databases: deps.databases ?? ((cwd, options) => listEnvironmentDatabases(cwd, options)),
         handleCancel: deps.handleCancel ?? defaultCancelHandler,
     };
 }
@@ -80,6 +83,24 @@ async function optionalTextArg(deps, message, fallback) {
         placeholder: fallback,
     }), fallback, deps);
 }
+async function databaseArg(cwd, deps, message, fallback, options = {}) {
+    const databases = await deps.databases(cwd, options);
+    if (databases.length > 0) {
+        const selected = await deps.list({
+            message: menuPromptMessage(message, 'back'),
+            options: [
+                ...databases.map((database) => ({ value: database, label: database })),
+                { value: manualDatabaseValue, label: 'Manual entry' },
+            ],
+            initialValue: databases.includes(fallback) ? fallback : databases[0],
+        });
+        deps.handleCancel(selected, 'back');
+        if (selected !== manualDatabaseValue) {
+            return String(selected);
+        }
+    }
+    return optionalTextArg(deps, message, fallback);
+}
 async function optionalModules(cwd, deps) {
     const modules = await detectedModules(cwd);
     if (modules.length === 0) {
@@ -120,19 +141,16 @@ export async function collectDailyActionArgs(command, cwd, promptDepsArg = {}) {
         return [await optionalTextArg(deps, 'Service', 'odoo')];
     }
     if (command === 'psql') {
-        return [await optionalTextArg(deps, 'Database', 'postgres')];
+        return [await databaseArg(cwd, deps, 'Database', 'postgres', { includeMaintenance: true })];
     }
     if (command === 'install' || command === 'update') {
         const modules = await moduleArg(cwd, deps);
-        const db = asString(await deps.text({
-            message: menuPromptMessage('Database (optional)', 'back'),
-            placeholder: 'devel',
-        }), '', deps);
-        return db ? [modules, db] : [modules];
+        const db = await databaseArg(cwd, deps, 'Odoo database', 'devel');
+        return [modules, db];
     }
     if (command === 'test') {
         const modules = await moduleArg(cwd, deps);
-        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const db = await databaseArg(cwd, deps, 'Odoo database', 'devel');
         const mode = asString(await deps.list({
             message: menuPromptMessage('Mode', 'back'),
             options: [
@@ -151,17 +169,17 @@ export async function collectDailyActionArgs(command, cwd, promptDepsArg = {}) {
     }
     if (command === 'pot') {
         const modules = await moduleArg(cwd, deps);
-        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const db = await databaseArg(cwd, deps, 'Odoo database', 'devel');
         const output = await optionalTextArg(deps, 'Output file', `i18n/${modules}.pot`);
         return [modules, db, output];
     }
     if (command === 'resetdb') {
-        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const db = await databaseArg(cwd, deps, 'Odoo database', 'devel');
         const modules = await optionalModules(cwd, deps);
         return modules ? [db, modules] : [db];
     }
     if (command === 'snapshot') {
-        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const db = await databaseArg(cwd, deps, 'Odoo database', 'devel');
         const snapshotName = await optionalTextArg(deps, 'Snapshot name', 'before-update');
         return [db, snapshotName];
     }
@@ -170,7 +188,7 @@ export async function collectDailyActionArgs(command, cwd, promptDepsArg = {}) {
             message: menuPromptMessage('Snapshot name', 'back'),
             validate: (value) => (value.trim() ? undefined : 'Enter the snapshot name.'),
         }), 'Snapshot name is required.', deps);
-        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const db = await databaseArg(cwd, deps, 'Odoo database', 'devel');
         return [snapshotName, db];
     }
     return [];