@wpmoo/odoo 0.8.46 → 0.8.48

package/README.md

@@ -1,14 +1,8 @@
-# @wpmoo/odoo
-
 ![WPMoo Odoo lifecycle tooling across development, staging, and production](docs/assets/wpmoo-banner.png)
 
 
 [![CI](https://img.shields.io/github/actions/workflow/status/wpmoo-org/wpmoo-odoo/ci.yml?branch=main&label=CI&style=flat-square)](https://github.com/wpmoo-org/wpmoo-odoo/actions/workflows/ci.yml) [![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&style=flat-square)](https://github.com/wpmoo-org/wpmoo-odoo) [![npm](https://img.shields.io/npm/v/@wpmoo/odoo?label=npm&logo=npm&style=flat-square&color=blue)](https://www.npmjs.com/package/@wpmoo/odoo) [![Coverage Status](https://img.shields.io/coverallsCoverage/github/wpmoo-org/wpmoo-odoo?branch=main&label=coverage&logo=coveralls&style=flat-square&color=blue)](https://coveralls.io/github/wpmoo-org/wpmoo-odoo?branch=main) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](LICENSE) [![Odoo Tool](https://img.shields.io/badge/Odoo-Tool-714B67?style=flat-square)](https://github.com/wpmoo-org/wpmoo-odoo) [![Buy Me a Coffee](https://img.shields.io/badge/Buy%20me%20a%20coffee-FFDD00?logo=buymeacoffee&logoColor=000000&style=flat-square)](https://www.buymeacoffee.com/cangir)
 
-
-
-
-
 WPMoo Odoo lifecycle tooling for development, staging, and production workflows.
 
 The CLI currently creates Docker Compose based Odoo environments, adds source
@@ -58,16 +52,26 @@ npx @wpmoo/odoo
 The wizard is context-aware. If the current directory is not already a WPMoo
 Odoo development environment, it starts the create flow directly.
 
-Inside an existing environment, it shows maintenance actions:
+Inside an existing environment, it opens the cockpit. The cockpit includes
+`Command palette /` for slash-style search across services, modules, database,
+diagnostics, repositories, and maintenance categories, plus guided category
+menus for common workflows.
 
 ```text
-Add source repo
-Remove source repo
-Add module to source repo
-Remove module from source repo
-Safe reset environment
+Command palette /
+Services
+Modules
+Database
+Diagnostics
+Repositories
+Maintenance
+Exit
 ```
 
+Direct commands remain available for scripts and repeatable terminal workflows,
+such as `npx @wpmoo/odoo status`, `npx @wpmoo/odoo test sale --db devel`, and
+`npx @wpmoo/odoo logs odoo`.
+
 Non-interactive:
 
 ```bash

package/dist/cli.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 import { confirm, intro, isCancel, note, outro, select, text } from '@clack/prompts';
+import { realpathSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { commandFromArgs, defaultTargetForProduct, isHelpRequested, isVersionRequested, optionsFromArgs, parseArgs, stripInternalFlags, } from './args.js';
+import { selectCockpitCommandFromPalette } from './cockpit/command-palette.js';
+import { collectDailyActionArgs } from './cockpit/daily-prompts.js';
+import { selectCockpitCategoryCommand, 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';
@@ -129,22 +134,15 @@ async function showStartup(argv, skipUpdateCheck) {
     }
     console.log();
 }
-async function selectEnvironmentActionFromMenu() {
-    intro('WPMoo Odoo Dev');
-    const action = await select({
-        message: 'What do you want to do?',
-        options: [
-            { value: 'add-repo', label: 'Add source repo' },
-            { value: 'remove-repo', label: 'Remove source repo' },
-            { value: 'add-module', label: 'Add module to source repo' },
-            { value: 'remove-module', label: 'Remove module from source repo' },
-            { value: 'reset', label: 'Safe reset environment' },
-            { value: 'exit', label: 'Exit' },
-        ],
-        initialValue: 'add-module',
-    });
-    handleCancel(action, 'back');
-    return action;
+async function selectCockpitCommandFromMenu() {
+    const selection = await selectCockpitTopLevelMenu();
+    if (selection.kind === 'exit') {
+        return 'exit';
+    }
+    if (selection.kind === 'command-palette') {
+        return selectCockpitCommandFromPalette();
+    }
+    return selectCockpitCategoryCommand(selection.category);
 }
 async function optionsFromPrompts(showIntro = true, cancelAction = 'exit') {
     if (showIntro) {
@@ -546,6 +544,71 @@ async function ensureGitHubRepositories(options, interactive) {
         process.exit(1);
     await createGitHubRepositories(missing, visibility);
 }
+async function runCockpitCommand(command, cwd) {
+    if (command.id === 'exit') {
+        return 'exit';
+    }
+    if (command.target.kind === 'daily') {
+        const argv = await collectDailyActionArgs(command.target.command, cwd);
+        if (!(await confirmCockpitCommandRisk(command))) {
+            note(`${command.slashAlias} was not run.`, 'Action skipped');
+            return 'continue';
+        }
+        await runDailyAction(command.target.command, argv, cwd);
+        note(`${command.slashAlias} completed.`, 'Done');
+        return 'continue';
+    }
+    if (command.id === 'status') {
+        note(await renderEnvironmentStatusForTarget(cwd), 'Environment status');
+        return 'continue';
+    }
+    if (command.id === 'doctor') {
+        note(await runDoctor(cwd), 'Doctor');
+        return 'continue';
+    }
+    if (command.id === 'add-repo') {
+        const options = await addRepoOptionsFromPrompts(false, 'back');
+        await ensureAddRepoGitHubRepository(options, 'back');
+        await addModuleRepo(options);
+        note(`Added source repo under ${options.target}/odoo/custom/src/private.`, 'Done');
+        return 'continue';
+    }
+    if (command.id === 'remove-repo') {
+        const options = await removeRepoOptionsFromPrompts([], false, 'back');
+        if (!(await confirmCockpitCommandRisk(command))) {
+            note(`Source repo ${options.repoPath} was not removed.`, 'Action skipped');
+            return 'continue';
+        }
+        await removeModuleRepo(options);
+        note(`Removed source repo ${options.repoPath} from ${options.target}.`, 'Done');
+        return 'continue';
+    }
+    if (command.id === 'add-module') {
+        const options = await addModuleOptionsFromPrompts(false, 'back');
+        await addModuleToSourceRepo(options);
+        note(`Added module ${options.moduleName} under source repo ${options.repoPath}.`, 'Done');
+        return 'continue';
+    }
+    if (command.id === 'remove-module') {
+        const options = await removeModuleOptionsFromPrompts(false, 'back');
+        if (!(await confirmCockpitCommandRisk(command))) {
+            note(`Module ${options.moduleName} was not removed.`, 'Action skipped');
+            return 'continue';
+        }
+        await removeModuleFromSourceRepo(options);
+        note(`Removed module ${options.moduleName} from source repo ${options.repoPath}.`, 'Done');
+        return 'continue';
+    }
+    if (command.id === 'safe-reset') {
+        const options = { target: cwd, stage: true };
+        await confirmSafeResetFromMenu(options);
+        await safeResetEnvironment(options);
+        note(`Safe reset refreshed generated environment files in ${cwd}.`, 'Done');
+        return 'continue';
+    }
+    note(`Unknown cockpit command: ${command.slashAlias}`, 'No action');
+    return 'continue';
+}
 export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd()) {
     installPromptCancelKeyTracker();
     const rawArgv = cliArgv;
@@ -570,44 +633,19 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
             outro(`Created Odoo dev overlay in ${resolvedOptions.target}. Review staged changes, then commit.`);
             return;
         }
+        intro('WPMoo Odoo Dev');
         while (true) {
             try {
                 const status = await getEnvironmentStatus(cwd);
                 note(renderEnvironmentStatusSummary(status), 'Environment status');
-                const action = await selectEnvironmentActionFromMenu();
-                if (action === 'exit') {
+                const command = await selectCockpitCommandFromMenu();
+                if (command === 'exit') {
                     return;
                 }
-                if (action === 'add-repo') {
-                    const options = await addRepoOptionsFromPrompts(false, 'back');
-                    await ensureAddRepoGitHubRepository(options, 'back');
-                    await addModuleRepo(options);
-                    outro(`Added source repo under ${options.target}/odoo/custom/src/private.`);
+                const outcome = await runCockpitCommand(command, cwd);
+                if (outcome === 'exit') {
                     return;
                 }
-                if (action === 'remove-repo') {
-                    const options = await removeRepoOptionsFromPrompts([], false, 'back');
-                    await removeModuleRepo(options);
-                    outro(`Removed source repo ${options.repoPath} from ${options.target}.`);
-                    return;
-                }
-                if (action === 'add-module') {
-                    const options = await addModuleOptionsFromPrompts(false, 'back');
-                    await addModuleToSourceRepo(options);
-                    outro(`Added module ${options.moduleName} under source repo ${options.repoPath}.`);
-                    return;
-                }
-                if (action === 'remove-module') {
-                    const options = await removeModuleOptionsFromPrompts(false, 'back');
-                    await removeModuleFromSourceRepo(options);
-                    outro(`Removed module ${options.moduleName} from source repo ${options.repoPath}.`);
-                    return;
-                }
-                const options = { target: cwd, stage: true };
-                await confirmSafeResetFromMenu(options);
-                await safeResetEnvironment(options);
-                outro(`Safe reset refreshed generated environment files in ${cwd}.`);
-                return;
             }
             catch (error) {
                 if (isMenuBackSignal(error)) {
@@ -723,7 +761,19 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
     }
     outro(`Created Odoo dev overlay in ${resolvedOptions.target}. Review staged changes, then commit.`);
 }
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+export function isCliEntrypoint(metaUrl, argvPath = process.argv[1]) {
+    if (!argvPath)
+        return false;
+    try {
+        const entrypointUrl = pathToFileURL(realpathSync(fileURLToPath(metaUrl))).href;
+        const argvUrl = pathToFileURL(realpathSync(argvPath)).href;
+        return entrypointUrl === argvUrl;
+    }
+    catch {
+        return metaUrl === pathToFileURL(argvPath).href;
+    }
+}
+if (isCliEntrypoint(import.meta.url)) {
     runCli().catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         console.error(message);

package/dist/cockpit/command-palette.js

@@ -0,0 +1,19 @@
+import search from '@inquirer/search';
+import { searchCockpitCommands } from './command-registry.js';
+const defaultSearchPrompt = (config) => search(config);
+function commandChoice(command) {
+    return {
+        value: command,
+        name: `${command.slashAlias} ${command.label}`,
+        description: command.description,
+        short: command.id,
+    };
+}
+export async function selectCockpitCommandFromPalette(options = {}) {
+    const prompt = options.prompt ?? defaultSearchPrompt;
+    return prompt({
+        message: 'Search commands',
+        pageSize: 10,
+        source: (term) => searchCockpitCommands(term).map(commandChoice),
+    });
+}

package/dist/cockpit/command-registry.js

@@ -0,0 +1,91 @@
+const riskyCommandIds = new Set(['stop', 'resetdb', 'restore-snapshot', 'remove-repo', 'remove-module', 'safe-reset']);
+function dailyCommand(command, category, label, description, aliases = []) {
+    return {
+        id: command,
+        slashAlias: `/${command}`,
+        category,
+        label,
+        description,
+        isRisky: riskyCommandIds.has(command),
+        target: {
+            kind: 'daily',
+            command,
+        },
+        aliases,
+    };
+}
+function internalCommand(id, category, label, description, aliases = []) {
+    return {
+        id,
+        slashAlias: `/${id}`,
+        category,
+        label,
+        description,
+        isRisky: riskyCommandIds.has(id),
+        target: {
+            kind: 'internal',
+        },
+        aliases,
+    };
+}
+export const cockpitCommands = [
+    dailyCommand('start', 'services', 'Start services', 'Start the Odoo development services.', ['up', 'compose up']),
+    dailyCommand('stop', 'services', 'Stop services', 'Stop the Odoo development services.', ['down', 'compose down']),
+    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']),
+    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']),
+    dailyCommand('lint', 'modules', 'Run lint', 'Run the configured module lint checks.', ['check', 'quality']),
+    dailyCommand('pot', 'modules', 'Generate POT', 'Generate translation template files for a module.', ['translation', 'i18n']),
+    dailyCommand('psql', 'database', 'Open psql', 'Open a PostgreSQL prompt for an environment database.', ['postgres', 'sql']),
+    dailyCommand('snapshot', 'database', 'Create snapshot', 'Create a database snapshot.', ['backup', 'dump']),
+    dailyCommand('restore-snapshot', 'database', 'Restore snapshot', 'Restore a database from a named snapshot.', ['restore', 'snapshot restore']),
+    dailyCommand('resetdb', 'database', 'Reset database', 'Reset an environment database.', ['reset db', 'database reset']),
+    internalCommand('status', 'diagnostics', 'Environment status', 'Show a summary of the current environment state.', [
+        'state',
+        'summary',
+    ]),
+    internalCommand('doctor', 'diagnostics', 'Run doctor', 'Run environment diagnostics and report actionable issues.', [
+        'diagnose',
+        'health',
+    ]),
+    internalCommand('add-repo', 'repositories', 'Add source repo', 'Add a source repository as an environment submodule.', [
+        'repository add',
+        'source add',
+    ]),
+    internalCommand('remove-repo', 'repositories', 'Remove source repo', 'Remove a source repository from the environment.', ['repository remove', 'source remove']),
+    internalCommand('add-module', 'modules', 'Add module', 'Add a module folder to a source repository.', ['module add']),
+    internalCommand('remove-module', 'modules', 'Remove module', 'Remove a module folder from a source repository.', ['module remove']),
+    internalCommand('safe-reset', 'maintenance', 'Safe reset environment', 'Refresh generated environment files while preserving source repositories.', ['reset', 'refresh']),
+    internalCommand('exit', 'maintenance', 'Exit', 'Leave the command palette.', ['quit', 'back']),
+];
+const defaultCommandIds = new Set(['start', 'logs', 'test', 'status', 'doctor', 'exit']);
+export function normalizeCockpitSearchTerm(term) {
+    return (term ?? '').trim().toLowerCase().replace(/\s+/g, ' ');
+}
+function commandSearchFields(command) {
+    return [command.slashAlias, command.id, command.label, command.category, command.description, ...command.aliases].map(normalizeCockpitSearchTerm);
+}
+function exactMatchScore(command, term) {
+    const bareTerm = term.startsWith('/') ? term.slice(1) : term;
+    if (normalizeCockpitSearchTerm(command.slashAlias) === term)
+        return 0;
+    if (normalizeCockpitSearchTerm(command.id) === bareTerm)
+        return 0;
+    if (normalizeCockpitSearchTerm(command.label) === term)
+        return 1;
+    if (command.aliases.map(normalizeCockpitSearchTerm).includes(term))
+        return 2;
+    return 10;
+}
+export function searchCockpitCommands(term) {
+    const normalizedTerm = normalizeCockpitSearchTerm(term);
+    if (!normalizedTerm) {
+        return cockpitCommands.filter((command) => defaultCommandIds.has(command.id));
+    }
+    return cockpitCommands
+        .filter((command) => commandSearchFields(command).some((field) => field.includes(normalizedTerm)))
+        .sort((left, right) => exactMatchScore(left, normalizedTerm) - exactMatchScore(right, normalizedTerm));
+}

package/dist/cockpit/daily-prompts.js

@@ -0,0 +1,173 @@
+import { isCancel, select, text } from '@clack/prompts';
+import { listModulesInSourceRepo } from '../module-actions.js';
+import { listModuleRepos } from '../repo-actions.js';
+import { handlePromptCancel, menuPromptMessage, } from '../menu-navigation.js';
+const manualModuleValue = '__wpmoo_manual_module_entry__';
+function defaultCancelHandler(value, action) {
+    handlePromptCancel(isCancel(value), action);
+}
+function promptDeps(deps = {}) {
+    return {
+        select: deps.select ?? ((options) => select(options)),
+        text: deps.text ?? ((options) => text(options)),
+        list: deps.list ?? ((options) => select(options)),
+        handleCancel: deps.handleCancel ?? defaultCancelHandler,
+    };
+}
+function asString(value, fallback, deps) {
+    deps.handleCancel(value, 'back');
+    return typeof value === 'string' && value.trim() ? value.trim() : fallback;
+}
+function requiredString(value, message, deps) {
+    deps.handleCancel(value, 'back');
+    if (typeof value === 'string' && value.trim()) {
+        return value.trim();
+    }
+    throw new Error(message);
+}
+async function detectedModules(cwd) {
+    try {
+        const repos = await listModuleRepos(cwd);
+        const modules = await Promise.all(repos.map(async (repo) => {
+            try {
+                return await listModulesInSourceRepo(cwd, repo);
+            }
+            catch {
+                return [];
+            }
+        }));
+        return [...new Set(modules.flat())].sort();
+    }
+    catch {
+        return [];
+    }
+}
+async function moduleArg(cwd, deps, message = 'Module(s)') {
+    const modules = await detectedModules(cwd);
+    if (modules.length === 0) {
+        return requiredString(await deps.text({
+            message: menuPromptMessage(message, 'back'),
+            placeholder: 'sale,stock',
+            validate: (value) => (value.trim() ? undefined : 'Enter one or more module technical names.'),
+        }), 'Module is required.', deps);
+    }
+    const selected = await deps.select({
+        message: menuPromptMessage(message, 'back'),
+        options: [
+            ...modules.map((moduleName) => ({ value: moduleName, label: moduleName })),
+            { value: manualModuleValue, label: 'Manual entry' },
+        ],
+        initialValue: modules[0],
+    });
+    deps.handleCancel(selected, 'back');
+    if (selected !== manualModuleValue) {
+        return String(selected);
+    }
+    return requiredString(await deps.text({
+        message: menuPromptMessage('Module(s)', 'back'),
+        placeholder: modules.join(','),
+        validate: (value) => (value.trim() ? undefined : 'Enter one or more module technical names.'),
+    }), 'Module is required.', deps);
+}
+async function optionalTextArg(deps, message, fallback) {
+    return asString(await deps.text({
+        message: menuPromptMessage(message, 'back'),
+        defaultValue: fallback,
+        placeholder: fallback,
+    }), fallback, deps);
+}
+async function optionalModules(cwd, deps) {
+    const modules = await detectedModules(cwd);
+    if (modules.length === 0) {
+        const manualModules = asString(await deps.text({
+            message: menuPromptMessage('Module(s) to include (optional)', 'back'),
+            placeholder: 'sale,stock',
+        }), '', deps);
+        return manualModules || undefined;
+    }
+    const selected = await deps.select({
+        message: menuPromptMessage('Module(s) to include (optional)', 'back'),
+        options: [
+            { value: '', label: 'All modules' },
+            ...modules.map((moduleName) => ({ value: moduleName, label: moduleName })),
+            { value: manualModuleValue, label: 'Manual entry' },
+        ],
+        initialValue: '',
+    });
+    deps.handleCancel(selected, 'back');
+    if (selected === '') {
+        return undefined;
+    }
+    if (selected !== manualModuleValue) {
+        return String(selected);
+    }
+    const manualModules = asString(await deps.text({
+        message: menuPromptMessage('Module(s) to include', 'back'),
+        placeholder: modules.join(','),
+    }), '', deps);
+    return manualModules || undefined;
+}
+export async function collectDailyActionArgs(command, cwd, promptDepsArg = {}) {
+    const deps = promptDeps(promptDepsArg);
+    if (['start', 'restart', 'shell', 'lint', 'stop'].includes(command)) {
+        return [];
+    }
+    if (command === 'logs') {
+        return [await optionalTextArg(deps, 'Service', 'odoo')];
+    }
+    if (command === 'psql') {
+        return [await optionalTextArg(deps, 'Database', 'postgres')];
+    }
+    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];
+    }
+    if (command === 'test') {
+        const modules = await moduleArg(cwd, deps);
+        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const mode = asString(await deps.list({
+            message: menuPromptMessage('Mode', 'back'),
+            options: [
+                { value: 'update', label: 'update' },
+                { value: 'init', label: 'init' },
+            ],
+            initialValue: 'update',
+        }), 'update', deps);
+        const tags = asString(await deps.text({
+            message: menuPromptMessage('Tags (optional)', 'back'),
+            placeholder: '/sale',
+        }), '', deps);
+        return tags
+            ? [modules, '--db', db, '--mode', mode, '--tags', tags]
+            : [modules, '--db', db, '--mode', mode];
+    }
+    if (command === 'pot') {
+        const modules = await moduleArg(cwd, deps);
+        const db = await optionalTextArg(deps, '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 modules = await optionalModules(cwd, deps);
+        return modules ? [db, modules] : [db];
+    }
+    if (command === 'snapshot') {
+        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const snapshotName = await optionalTextArg(deps, 'Snapshot name', 'before-update');
+        return [db, snapshotName];
+    }
+    if (command === 'restore-snapshot') {
+        const snapshotName = requiredString(await deps.text({
+            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');
+        return [snapshotName, db];
+    }
+    return [];
+}

package/dist/cockpit/menu.js

@@ -0,0 +1,88 @@
+import { isCancel, select } from '@clack/prompts';
+import { cockpitCommands, } from './command-registry.js';
+import { handlePromptCancel, menuPromptMessage, MenuBackSignal } from '../menu-navigation.js';
+export const cockpitMenuBackValue = '__wpmoo_cockpit_menu_back__';
+const categoryLabels = {
+    services: 'Services',
+    modules: 'Modules',
+    database: 'Database',
+    diagnostics: 'Diagnostics',
+    repositories: 'Repositories',
+    maintenance: 'Maintenance',
+};
+const topLevelOptions = [
+    { value: 'command-palette', label: 'Command palette /' },
+    { value: 'services', label: categoryLabels.services },
+    { value: 'modules', label: categoryLabels.modules },
+    { value: 'database', label: categoryLabels.database },
+    { value: 'diagnostics', label: categoryLabels.diagnostics },
+    { value: 'repositories', label: categoryLabels.repositories },
+    { value: 'maintenance', label: categoryLabels.maintenance },
+    { value: 'exit', label: 'Exit' },
+];
+const categories = new Set([
+    'services',
+    'modules',
+    'database',
+    'diagnostics',
+    'repositories',
+    'maintenance',
+]);
+function defaultSelect(options) {
+    return select(options);
+}
+function defaultCancelHandler(value, action) {
+    handlePromptCancel(isCancel(value), action);
+}
+function menuDeps(deps = {}) {
+    return {
+        select: deps.select ?? defaultSelect,
+        handleCancel: deps.handleCancel ?? defaultCancelHandler,
+    };
+}
+function isCockpitCommandCategory(value) {
+    return typeof value === 'string' && categories.has(value);
+}
+export async function selectCockpitTopLevelMenu(options = {}) {
+    const deps = menuDeps(options);
+    const selected = await deps.select({
+        message: 'What do you want to do?',
+        options: [...topLevelOptions],
+        initialValue: 'command-palette',
+    });
+    deps.handleCancel(selected, 'exit');
+    if (selected === 'command-palette') {
+        return { kind: 'command-palette' };
+    }
+    if (selected === 'exit') {
+        return { kind: 'exit' };
+    }
+    if (isCockpitCommandCategory(selected)) {
+        return {
+            kind: 'category',
+            category: selected,
+        };
+    }
+    return { kind: 'exit' };
+}
+export async function selectCockpitCategoryCommand(category, options = {}) {
+    const deps = menuDeps(options);
+    const commands = cockpitCommands.filter((command) => command.category === category);
+    const selected = await deps.select({
+        message: menuPromptMessage(categoryLabels[category], 'back'),
+        options: [
+            ...commands.map((command) => ({
+                value: command,
+                label: command.label,
+                hint: command.description,
+            })),
+            { value: cockpitMenuBackValue, label: 'Back' },
+        ],
+        initialValue: commands[0],
+    });
+    deps.handleCancel(selected, 'back');
+    if (selected === cockpitMenuBackValue) {
+        throw new MenuBackSignal();
+    }
+    return selected;
+}

package/dist/cockpit/safety.js

@@ -0,0 +1,22 @@
+import { confirm, isCancel } from '@clack/prompts';
+import { handlePromptCancel, menuPromptMessage } from '../menu-navigation.js';
+function defaultHandleCancel(value, action) {
+    handlePromptCancel(isCancel(value), action);
+}
+function riskConfirmationMessage(command, action) {
+    return menuPromptMessage(`Run ${command.slashAlias} ${command.label}? This can change or remove environment state.`, action);
+}
+export async function confirmCockpitCommandRisk(command, deps = {}) {
+    if (!command.isRisky) {
+        return true;
+    }
+    const prompt = deps.confirm ?? confirm;
+    const cancelAction = deps.cancelAction ?? 'back';
+    const approved = await prompt({
+        message: riskConfirmationMessage(command, cancelAction),
+        initialValue: false,
+    });
+    const handleCancel = deps.handleCancel ?? defaultHandleCancel;
+    handleCancel(approved, cancelAction);
+    return approved === true;
+}

package/dist/help.js

@@ -67,6 +67,12 @@ Daily actions:
   Generated environments also include ./moo for local compose commands such as ./moo start.
   Use ./moo or npx @wpmoo/odoo with the same daily action arguments.
 
+Cockpit:
+  Run npx @wpmoo/odoo inside a generated environment to open the cockpit.
+  Use Command palette / to search slash commands across services, modules, database,
+  diagnostics, repositories, and maintenance categories.
+  Direct commands such as npx @wpmoo/odoo status and npx @wpmoo/odoo test remain available.
+
 Status and doctor:
   status: fast and offline. Reads local environment metadata and files only.
   doctor: deeper health check. May check Docker CLI access and GitHub workflows.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpmoo/odoo",
-  "version": "0.8.46",
+  "version": "0.8.48",
   "description": "WPMoo Odoo lifecycle tooling for development, staging, and production workflows.",
   "type": "module",
   "repository": {
@@ -34,7 +34,7 @@
     "docs/assets"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=20.17"
   },
   "scripts": {
     "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
@@ -47,6 +47,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
+    "@inquirer/search": "^4.1.9",
     "execa": "^9.6.0"
   },
   "devDependencies": {