@wpmoo/toolkit 0.9.5 → 0.9.6

package/dist/cli.js

@@ -2,20 +2,25 @@
 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';
@@ -211,6 +216,24 @@ function clearCockpitScreen() {
         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));
@@ -603,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';
 }
@@ -801,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',
@@ -827,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,
     };
@@ -968,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;
         }
-        await runDailyAction(command.target.command, argv, cwd);
+        const returnedByBack = await runDailyActionResultPage(dailyCommand, argv, cwd, command.label, selectedModule.moduleName, commandCompletedLabel(dailyCommand));
+        if (!returnedByBack) {
+            return;
+        }
+    }
+}
+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') {
@@ -990,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');
@@ -1014,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';
@@ -1058,6 +1386,11 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
         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(serviceStatus);
@@ -1071,6 +1404,7 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
                 }
                 catch (error) {
                     if (isMenuBackSignal(error)) {
+                        renderCockpitMenuShell();
                         continue;
                     }
                     commandFailed = true;
@@ -1084,9 +1418,7 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
                 }
                 status = await getEnvironmentStatus(cwd);
                 serviceStatus = await getServiceRuntimeStatus(cwd, status);
-                clearCockpitScreen();
-                console.log(renderBanner(renderCockpitStatusLines(status, serviceStatus, lastStatus), { version: startupVersionLine() }));
-                console.log();
+                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 [];

package/dist/cockpit/menu.js

@@ -116,6 +116,7 @@ function defaultCommand(serviceStatus) {
 export async function selectCockpitTopLevelMenu(options = {}) {
     const deps = menuDeps(options);
     const choices = topLevelChoices(options.serviceStatus);
+    const cancelAction = 'back';
     const selected = await deps.select({
         message: '',
         choices: [...choices],
@@ -124,8 +125,10 @@ export async function selectCockpitTopLevelMenu(options = {}) {
         loop: false,
         hideMessage: true,
         disabledError: disabledError(options.serviceStatus),
+        navigationWarning: options.navigationWarning,
+        escapeBehavior: 'ignore',
     });
-    deps.handleCancel(selected, 'exit');
+    deps.handleCancel(selected, cancelAction);
     if (selected === 'exit') {
         return { kind: 'exit' };
     }

package/dist/cockpit/module-action-menu.js

@@ -0,0 +1,40 @@
+import { handlePromptCancel, } from '../menu-navigation.js';
+import { isPromptCancel, selectPrompt, } from '../prompts/index.js';
+const moduleActions = [
+    { id: 'delete', label: 'Delete module' },
+    { id: 'update', label: 'Update' },
+    { id: 'test', label: 'Test' },
+    { id: 'lint', label: 'Lint' },
+];
+function defaultCancelHandler(value, action) {
+    handlePromptCancel(isPromptCancel(value), action);
+}
+function deps(options = {}) {
+    return {
+        select: options.select ?? ((options) => selectPrompt(options)),
+        handleCancel: options.handleCancel ?? defaultCancelHandler,
+    };
+}
+export function moduleActionChoices() {
+    return moduleActions.map(({ id, label }) => ({ value: id, name: label }));
+}
+function isModuleAction(value) {
+    return typeof value === 'string' && moduleActions.some((action) => action.id === value);
+}
+export async function selectModuleAction(module, options = {}) {
+    const promptDeps = deps(options);
+    const cancelAction = options.cancelAction ?? 'back';
+    const selected = await promptDeps.select({
+        message: `Module: ${module.moduleName}`,
+        choices: moduleActionChoices(),
+        default: 'update',
+        loop: false,
+        hideMessage: true,
+        navigationHelp: cancelAction === 'back' ? 'back' : 'exit',
+    });
+    promptDeps.handleCancel(selected, cancelAction);
+    if (isModuleAction(selected)) {
+        return selected;
+    }
+    return undefined;
+}

package/dist/cockpit/module-browser.js

@@ -0,0 +1,117 @@
+import { styleText } from 'node:util';
+import { listModulesInEnvironment, } from '../module-actions.js';
+import { handlePromptCancel, } from '../menu-navigation.js';
+import { isPromptCancel, promptSeparator, selectPrompt, } from '../prompts/index.js';
+const sourceTypeLabels = {
+    private: 'Private',
+    oca: 'OCA',
+    external: 'External',
+};
+const sourceTypeOrder = ['private', 'oca', 'external'];
+const minimumPageSize = 8;
+const reservedRows = 7;
+function rgb(red, green, blue, value) {
+    return `\u001B[38;2;${red};${green};${blue}m${value}\u001B[39m`;
+}
+function dim(value) {
+    return styleText('dim', value, { validateStream: false });
+}
+function categoryHeading(label) {
+    return `\u001B[1D${rgb(143, 211, 255, label)}`;
+}
+function repositoryHeading(repoLabel, repoContext, width) {
+    return `\u001B[1D${rgb(143, 211, 255, `📁 ${repoLabel.padEnd(width)}`)}${dim(`    ${repoContext}`)}`;
+}
+function repositoryContext(module) {
+    return module.repoSlug ?? module.repoPath;
+}
+function sourceContext(module) {
+    return `${module.sourceType}/${module.repoPath}`;
+}
+export function renderModuleDetails(module) {
+    return [
+        `Name: ${module.moduleName}`,
+        `Source: ${sourceContext(module)}`,
+        `Path: odoo/custom/src/${module.sourceType}/${module.repoPath}/${module.moduleName}`,
+    ].join('\n');
+}
+function moduleChoiceName(module, width) {
+    return `${rgb(226, 184, 96, ` ${module.moduleName.padEnd(width)}`)}${dim(`  ${sourceContext(module)}`)}`;
+}
+function pageSize(choiceCount) {
+    const terminalRows = process.stdout.rows;
+    if (!terminalRows || terminalRows <= 0) {
+        return Math.min(choiceCount, 12);
+    }
+    return Math.min(choiceCount, Math.max(minimumPageSize, terminalRows - reservedRows));
+}
+function defaultCancelHandler(value, action) {
+    handlePromptCancel(isPromptCancel(value), action);
+}
+function deps(options = {}) {
+    return {
+        select: options.select ?? ((selectOptions) => selectPrompt(selectOptions)),
+        handleCancel: options.handleCancel ?? defaultCancelHandler,
+    };
+}
+export function moduleBrowserChoices(modules) {
+    const moduleWidth = Math.max(...modules.map((module) => module.moduleName.length), 1);
+    const repositoryWidth = Math.max(...modules.map((module) => module.repoPath.length), 1);
+    const choices = [];
+    for (const sourceType of sourceTypeOrder) {
+        const sourceModules = modules
+            .filter((module) => module.sourceType === sourceType)
+            .sort((left, right) => left.repoPath.localeCompare(right.repoPath) || left.moduleName.localeCompare(right.moduleName));
+        if (sourceModules.length === 0) {
+            continue;
+        }
+        if (choices.length > 0) {
+            choices.push(promptSeparator(' '));
+        }
+        choices.push(promptSeparator(categoryHeading(sourceTypeLabels[sourceType])));
+        const modulesByRepo = new Map();
+        for (const module of sourceModules) {
+            const bucket = modulesByRepo.get(module.repoPath);
+            if (bucket) {
+                bucket.push(module);
+            }
+            else {
+                modulesByRepo.set(module.repoPath, [module]);
+            }
+        }
+        for (const [repoPath, repoModules] of modulesByRepo) {
+            const sortedRepoModules = [...repoModules].sort((left, right) => left.moduleName.localeCompare(right.moduleName));
+            const headingLabel = repositoryHeading(repoPath, repositoryContext(sortedRepoModules[0]), repositoryWidth);
+            choices.push(promptSeparator(headingLabel));
+            choices.push(...sortedRepoModules.map((module) => ({
+                value: module,
+                name: moduleChoiceName(module, moduleWidth),
+                short: module.moduleName,
+            })));
+        }
+    }
+    return choices;
+}
+export async function selectModuleFromBrowser(target, options = {}) {
+    const modules = await listModulesInEnvironment(target);
+    if (modules.length === 0) {
+        return undefined;
+    }
+    const moduleChoices = moduleBrowserChoices(modules);
+    const promptDeps = deps(options);
+    const cancelAction = options.cancelAction ?? 'back';
+    const selected = await promptDeps.select({
+        message: '',
+        choices: moduleChoices,
+        default: modules[0],
+        pageSize: pageSize(moduleChoices.length),
+        loop: false,
+        hideMessage: true,
+        navigationHelp: cancelAction === 'back' ? 'back' : 'exit',
+    });
+    promptDeps.handleCancel(selected, cancelAction);
+    if (typeof selected === 'object' && selected !== null && 'moduleName' in selected) {
+        return selected;
+    }
+    return undefined;
+}

package/dist/daily-actions.js

@@ -18,6 +18,10 @@ export const dailyActionCommands = [
     'lint',
     'pot',
 ];
+const ANSI_DIM_INFO = '\u001B[2m\u001B[38;2;120;157;181m';
+const ANSI_WARNING = '\u001B[33m';
+const ANSI_DEFAULT_FOREGROUND = '\u001B[39m';
+const ANSI_RESET = '\u001B[0m';
 const dailyActionCommandSet = new Set(dailyActionCommands);
 export const dailyActionScripts = {
     start: 'up.sh',
@@ -56,7 +60,7 @@ function usage(command) {
     if (command === 'update')
         return 'Usage: wpmoo update <module[,module]> [db]';
     if (command === 'test')
-        return 'Usage: wpmoo test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]';
+        return 'Usage: wpmoo test <module[,module]> [--db <db>] [--mode auto|init|update] [--tags <tags>]';
     if (command === 'resetdb')
         return 'Usage: wpmoo resetdb [db] [module[,module]]';
     if (command === 'snapshot')
@@ -111,8 +115,8 @@ function testArgs(argv) {
         const value = rest[index + 1];
         if (!value || value.startsWith('--'))
             throw new Error(`Missing value for ${option}`);
-        if (option === '--mode' && value !== 'init' && value !== 'update') {
-            throw new Error('Invalid value for --mode: expected init or update');
+        if (option === '--mode' && value !== 'auto' && value !== 'init' && value !== 'update') {
+            throw new Error('Invalid value for --mode: expected auto, init, or update');
         }
         index += 1;
     }
@@ -185,6 +189,39 @@ async function spawnDailyAction(plan) {
         throw new Error(`Daily action script exited with code ${exitCode ?? 'unknown'}: ${plan.scriptPath}`);
     }
 }
+function renderDailyActionOutputLine(line) {
+    if (line.startsWith('WARNING:')) {
+        return `${ANSI_WARNING}WARNING:${ANSI_DEFAULT_FOREGROUND}${ANSI_DIM_INFO}${line.slice('WARNING:'.length)}${ANSI_RESET}`;
+    }
+    if (line === "Running as user 'root' is a security risk.") {
+        return `${ANSI_DIM_INFO}${line}${ANSI_RESET}`;
+    }
+    return line;
+}
+export function renderDailyActionOutput(output) {
+    return output
+        .split(/(\r?\n)/u)
+        .map((part) => (part === '\n' || part === '\r\n' ? part : renderDailyActionOutputLine(part)))
+        .join('');
+}
+async function spawnDailyActionWithStyledOutput(plan, writer) {
+    const child = spawn(plan.scriptPath, plan.args, {
+        cwd: plan.cwd,
+        stdio: ['inherit', 'pipe', 'pipe'],
+    });
+    child.stdout?.on('data', (chunk) => writer(renderDailyActionOutput(chunk.toString('utf8'))));
+    child.stderr?.on('data', (chunk) => writer(renderDailyActionOutput(chunk.toString('utf8'))));
+    const exitCode = await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('close', resolve);
+    });
+    if (exitCode !== 0) {
+        throw new Error(`Daily action script exited with code ${exitCode ?? 'unknown'}: ${plan.scriptPath}`);
+    }
+}
 export async function runDailyAction(command, argv, cwd = process.cwd(), runner = spawnDailyAction) {
     await runner(await dailyActionPlan(command, argv, cwd));
 }
+export async function runDailyActionWithStyledOutput(command, argv, cwd = process.cwd(), writer = (chunk) => process.stdout.write(chunk)) {
+    await spawnDailyActionWithStyledOutput(await dailyActionPlan(command, argv, cwd), writer);
+}

package/dist/databases.js

@@ -0,0 +1,46 @@
+import { spawn } from 'node:child_process';
+const maintenanceDatabases = new Set(['postgres']);
+const listDatabasesQuery = [
+    'SELECT datname',
+    'FROM pg_database',
+    'WHERE datistemplate = false',
+    "ORDER BY CASE WHEN datname = 'devel' THEN 0 WHEN datname = current_database() THEN 1 ELSE 2 END, datname;",
+].join(' ');
+export function parseDatabaseListOutput(output, options = {}) {
+    const seen = new Set();
+    const databases = [];
+    for (const line of output.split(/\r?\n/u)) {
+        const database = line.trim();
+        if (!/^[A-Za-z0-9_.-]+$/u.test(database) ||
+            database.startsWith('-') ||
+            seen.has(database) ||
+            (!options.includeMaintenance && maintenanceDatabases.has(database))) {
+            continue;
+        }
+        seen.add(database);
+        databases.push(database);
+    }
+    return databases;
+}
+export async function listEnvironmentDatabases(cwd, options = {}) {
+    const queryLiteral = JSON.stringify(listDatabasesQuery);
+    const command = [
+        `query=${queryLiteral}`,
+        '. ./scripts/lib.sh >/dev/null',
+        'compose exec -T db psql -U "${POSTGRES_USER:-odoo}" -d "${POSTGRES_DB:-postgres}" -Atc "$query"',
+    ].join(' && ');
+    return new Promise((resolve) => {
+        const child = spawn('bash', ['-lc', command], {
+            cwd,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        let output = '';
+        child.stdout?.on('data', (chunk) => {
+            output += chunk.toString('utf8');
+        });
+        child.on('error', () => resolve([]));
+        child.on('close', (code) => {
+            resolve(code === 0 ? parseDatabaseListOutput(output, options) : []);
+        });
+    });
+}

package/dist/help.js

@@ -30,7 +30,7 @@ Usage:
   npx @wpmoo/toolkit psql [db]
   npx @wpmoo/toolkit install <module[,module]> [db]
   npx @wpmoo/toolkit update <module[,module]> [db]
-  npx @wpmoo/toolkit test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]
+  npx @wpmoo/toolkit test <module[,module]> [--db <db>] [--mode auto|init|update] [--tags <tags>]
   npx @wpmoo/toolkit resetdb [db] [module[,module]]
   npx @wpmoo/toolkit snapshot [db] [snapshot-name]
   npx @wpmoo/toolkit restore-snapshot [--dry-run] <snapshot-name> [db]
@@ -118,7 +118,7 @@ Task recipes:
   Add OCA module:
     npx @wpmoo/toolkit add-module --repo sale-workflow --module sale_order_line_no_discount --source-type oca
   Run tests:
-    npx @wpmoo/toolkit test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]
+    npx @wpmoo/toolkit test <module[,module]> [--db <db>] [--mode auto|init|update] [--tags <tags>]
   Safe reset and recover:
     npx @wpmoo/toolkit snapshot [db] [snapshot-name]
     npx @wpmoo/toolkit reset --dry-run

package/dist/menu-navigation.js

@@ -10,10 +10,10 @@ export function isMenuBackSignal(error) {
     return error instanceof MenuBackSignal;
 }
 export function menuIntroTitle(title, action) {
-    return action === 'back' ? `${title} · Back (Esc)` : title;
+    return title;
 }
 export function menuPromptMessage(message, action) {
-    return action === 'back' ? `${message} · Esc to go back` : message;
+    return message;
 }
 export function promptCancelOutcome(cancelled, action, key) {
     if (!cancelled) {

package/dist/module-actions.js

@@ -4,8 +4,27 @@ import { addModuleToSourceRepoInAddonsYaml, removeModuleFromSourceRepoInAddonsYa
 import { readEnvironmentMetadata } from './environment.js';
 import { realGit, stageAll } from './git.js';
 import { pathUnderBase, validateModuleName, validateRepoPath } from './path-validation.js';
-import { readAddonsYaml, writeAddonsYaml } from './repo-actions.js';
+import { listModuleRepos, readAddonsYaml, writeAddonsYaml } from './repo-actions.js';
+import { listSources } from './source-actions.js';
+const sourceTypeSortOrder = ['private', 'oca', 'external'];
+const githubRepoUrlPattern = /^(?:https?:\/\/|git@)github\.com[/:]([^/]+)\/([^/.#?]+)(?:\.git)?(?:[/?#].*)?$/i;
 const validSourceTypes = ['private', 'oca', 'external'];
+function deriveRepoSlug(repoUrl) {
+    if (!repoUrl) {
+        return undefined;
+    }
+    const normalized = repoUrl.trim().replace(/[?#].*$/, '');
+    const match = githubRepoUrlPattern.exec(normalized);
+    if (!match) {
+        return undefined;
+    }
+    const owner = match[1]?.trim();
+    const repo = match[2]?.trim();
+    if (!owner || !repo) {
+        return undefined;
+    }
+    return `${owner}/${repo}`;
+}
 function normalizeSourceType(value) {
     return validSourceTypes.includes(value) ? value : 'private';
 }
@@ -94,6 +113,36 @@ export async function listModulesInSourceRepo(target, repoPath, sourceType) {
         return [];
     }
 }
+export async function listModulesInEnvironment(target) {
+    const sources = await listSources(target);
+    const sourceRepos = sources.length > 0
+        ? sources.map((source) => ({
+            repoPath: source.path,
+            sourceType: source.type,
+            repoUrl: source.url,
+        }))
+        : (await listModuleRepos(target)).map((repoPath) => ({ repoPath, sourceType: 'private' }));
+    const listedModules = await Promise.all(sourceRepos.map(async ({ repoPath, sourceType, repoUrl }) => {
+        try {
+            const moduleNames = await listModulesInSourceRepo(target, repoPath, sourceType);
+            const repoSlug = deriveRepoSlug(repoUrl);
+            return moduleNames.map((moduleName) => ({
+                moduleName,
+                repoPath,
+                sourceType,
+                ...(repoUrl ? { repoUrl } : {}),
+                ...(repoSlug ? { repoSlug } : {}),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }));
+    const sourceTypeOrder = new Map(sourceTypeSortOrder.map((sourceType, index) => [sourceType, index]));
+    return listedModules.flat().sort((left, right) => (sourceTypeOrder.get(left.sourceType) ?? 0) - (sourceTypeOrder.get(right.sourceType) ?? 0) ||
+        left.repoPath.localeCompare(right.repoPath) ||
+        left.moduleName.localeCompare(right.moduleName));
+}
 export async function removeModuleFromSourceRepo(options, git = realGit) {
     const repoPath = validateRepoPath(options.repoPath);
     const moduleName = validateModuleName(options.moduleName);

package/dist/prompts/index.js

@@ -3,7 +3,7 @@ import { styleText } from 'node:util';
 import inquirerSelect, { Separator as InquirerSeparator } from '@inquirer/select';
 import inquirerSearch from '@inquirer/search';
 import { confirm as inquirerConfirm, input as inquirerInput } from '@inquirer/prompts';
-import { recordPromptCancelKey } from '../menu-navigation.js';
+import { consumePromptCancelKey, recordPromptCancelKey } from '../menu-navigation.js';
 export const promptCancelled = Symbol.for('wpmoo.prompt.cancelled');
 export function promptSeparator(label) {
     return new InquirerSeparator(label);
@@ -46,10 +46,38 @@ function asInquirerSearchConfig(options) {
         pageSize: options.pageSize,
     };
 }
-function installEscapeAbortController(controller) {
+function isEscapeKey(key) {
+    if (typeof key !== 'object' || key === null) {
+        return false;
+    }
+    const candidate = key;
+    return candidate.name === 'escape' || candidate.sequence === '\u001B';
+}
+function installIgnoredEscapeFilter(options) {
     emitKeypressEvents(process.stdin);
+    const input = process.stdin;
+    const originalEmit = input.emit;
+    const patchedEmit = function patchedEmit(eventName, ...args) {
+        if (eventName === 'keypress' && isEscapeKey(args[1])) {
+            consumePromptCancelKey();
+            return true;
+        }
+        return Reflect.apply(originalEmit, this, [eventName, ...args]);
+    };
+    input.emit = patchedEmit;
+    return () => {
+        if (input.emit === patchedEmit) {
+            input.emit = originalEmit;
+        }
+    };
+}
+function installEscapeAbortController(controller, options = {}) {
+    emitKeypressEvents(process.stdin);
+    if (options.escapeBehavior === 'ignore') {
+        return installIgnoredEscapeFilter(options);
+    }
     const listener = (_value, key) => {
-        if (key.name !== 'escape' && key.sequence !== '\u001B') {
+        if (!isEscapeKey(key)) {
             return;
         }
         recordPromptCancelKey(key);
@@ -60,9 +88,9 @@ function installEscapeAbortController(controller) {
     process.stdin.on('keypress', listener);
     return () => process.stdin.off('keypress', listener);
 }
-async function withPromptCancelGuard(callback) {
+async function withPromptCancelGuard(callback, options = {}) {
     const controller = new AbortController();
-    const removeEscapeListener = installEscapeAbortController(controller);
+    const removeEscapeListener = installEscapeAbortController(controller, options);
     try {
         return await callback({ signal: controller.signal });
     }
@@ -92,9 +120,17 @@ function asInquirerSelectConfig(options) {
         loop: options.loop,
         hideMessage: options.hideMessage,
         disabledError: options.disabledError,
+        navigationHelp: options.navigationHelp,
+        navigationWarning: options.navigationWarning,
+        escapeBehavior: options.escapeBehavior,
     };
 }
-function hiddenSelectTheme(disabledError) {
+function renderedNavigationWarning(navigationWarning) {
+    const warning = typeof navigationWarning === 'function' ? navigationWarning() : navigationWarning;
+    return warning ? `\u001B[2m\u001B[38;2;226;184;96m${warning}\u001B[0m` : undefined;
+}
+function hiddenSelectTheme(disabledError, navigationHelp = 'exit', navigationWarning) {
+    const keysHelpTip = navigationHelp === 'back' ? '↑↓ navigate • ⏎ select • Esc to go back' : '↑↓ navigate • ⏎ select • Ctrl+C exit';
     return {
         prefix: '',
         icon: {
@@ -104,20 +140,30 @@ function hiddenSelectTheme(disabledError) {
             message: () => '',
             highlight: (text) => text,
             disabled: (text) => styleText('dim', text.replace(/ \(disabled\)$/u, ''), { validateStream: false }),
-            keysHelpTip: () => '↑↓ navigate • ⏎ select • Ctrl+C exit',
+            keysHelpTip: () => {
+                const warning = renderedNavigationWarning(navigationWarning);
+                return warning ? `${warning}\n${keysHelpTip}` : keysHelpTip;
+            },
         },
         i18n: disabledError ? { disabledError } : undefined,
     };
 }
 function withHiddenSelectMessage(config) {
-    if (!config.hideMessage) {
+    if (!config.hideMessage &&
+        !config.disabledError &&
+        !config.navigationHelp &&
+        !config.navigationWarning &&
+        !config.escapeBehavior) {
         return config;
     }
-    const { disabledError, hideMessage: _hideMessage, ...inquirerConfig } = config;
+    const { disabledError, hideMessage: _hideMessage, navigationHelp, navigationWarning, escapeBehavior: _escapeBehavior, ...inquirerConfig } = config;
+    if (!config.hideMessage) {
+        return inquirerConfig;
+    }
     return {
         ...inquirerConfig,
         message: '',
-        theme: hiddenSelectTheme(disabledError),
+        theme: hiddenSelectTheme(disabledError, navigationHelp, navigationWarning),
     };
 }
 function asInquirerConfirmConfig(options) {
@@ -143,10 +189,13 @@ export function isPromptCancel(value) {
     return value === promptCancelled;
 }
 export async function selectPrompt(options) {
+    const guardOptions = {
+        escapeBehavior: options.escapeBehavior,
+    };
     if (isClackSelectOptions(options)) {
-        return withPromptCancelGuard((context) => inquirerSelect(withHiddenSelectMessage(asInquirerSelectConfig(options)), context));
+        return withPromptCancelGuard((context) => inquirerSelect(withHiddenSelectMessage(asInquirerSelectConfig(options)), context), guardOptions);
     }
-    return withPromptCancelGuard((context) => inquirerSelect(withHiddenSelectMessage(options), context));
+    return withPromptCancelGuard((context) => inquirerSelect(withHiddenSelectMessage(options), context), guardOptions);
 }
 export async function inputPrompt(options) {
     return withPromptCancelGuard((context) => inquirerInput(asInquirerInputConfig(options), context));

package/dist/templates.js

@@ -431,7 +431,7 @@ usage() {
     "psql") echo "Usage: ./moo psql [db]" ;;
     "install") echo "Usage: ./moo install <module[,module]> [db]" ;;
     "update") echo "Usage: ./moo update <module[,module]> [db]" ;;
-    "test") echo "Usage: ./moo test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]" ;;
+    "test") echo "Usage: ./moo test <module[,module]> [--db <db>] [--mode auto|init|update] [--tags <tags>]" ;;
     "resetdb") echo "Usage: ./moo resetdb [db] [module[,module]]" ;;
     "snapshot") echo "Usage: ./moo snapshot [db] [snapshot-name]" ;;
     "restore-snapshot") echo "Usage: ./moo restore-snapshot [--dry-run] <snapshot-name> [db]" ;;
@@ -506,8 +506,8 @@ validate_test_args() {
           echo "Missing value for --mode" >&2
           exit 2
         fi
-        if [[ "$2" != "init" && "$2" != "update" ]]; then
-          echo "Invalid value for --mode: expected init or update" >&2
+        if [[ "$2" != "auto" && "$2" != "init" && "$2" != "update" ]]; then
+          echo "Invalid value for --mode: expected auto, init, or update" >&2
           exit 2
         fi
         shift 2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpmoo/toolkit",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "WPMoo Toolkit for development, staging, and production lifecycle workflows.",
   "type": "module",
   "repository": {