@wpmoo/toolkit 0.9.23 → 0.9.25

package/dist/cli.js

@@ -20,7 +20,8 @@ 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, removeModuleFromSourceRepo, } from './module-actions.js';
+import { addModuleToSourceRepo, listModulesInEnvironment, removeModuleFromSourceRepo, } from './module-actions.js';
+import { resolveModuleTarget } from './module-target-resolver.js';
 import { supportedOdooVersions } from './odoo-versions.js';
 import { renderRepositorySetupNote } from './prompt-copy.js';
 import { promptRepositoryUrl } from './prompt-repositories.js';
@@ -270,7 +271,17 @@ async function showStartup(argv, skipUpdateCheck, details) {
     console.log();
 }
 async function selectCockpitCommandFromMenu(serviceStatus, moduleCount, sourceRepoCount) {
-    const selection = await selectCockpitTopLevelMenu({ serviceStatus, moduleCount, sourceRepoCount });
+    const legacyServiceStatus = serviceStatus.kind === 'services-running' ||
+        serviceStatus.kind === 'db-ready' ||
+        serviceStatus.kind === 'odoo-not-ready' ||
+        serviceStatus.kind === 'fully-ready'
+        ? { kind: 'running' }
+        : serviceStatus;
+    const selection = await selectCockpitTopLevelMenu({
+        serviceStatus: legacyServiceStatus,
+        moduleCount,
+        sourceRepoCount,
+    });
     if (selection.kind === 'exit') {
         return 'exit';
     }
@@ -1109,6 +1120,46 @@ function dailyActionSelectedLabel(command, argv) {
     }
     return undefined;
 }
+function dailyActionModuleArgIndex(command) {
+    return ['install', 'update', 'test', 'pot'].includes(command) ? 0 : undefined;
+}
+function moduleTargetLabel(module) {
+    return `${module.moduleName} (${module.sourceType}/${module.repoPath})`;
+}
+function moduleTargetResolutionError(resolution) {
+    const candidates = resolution.candidates.map(moduleTargetLabel).join(', ');
+    if (resolution.kind === 'ambiguous') {
+        return new Error(`Ambiguous module target "${resolution.query}": ${candidates}.`);
+    }
+    return new Error(candidates
+        ? `No module matches "${resolution.query}". Did you mean: ${candidates}?`
+        : `No module matches "${resolution.query}".`);
+}
+async function resolveDailyActionModuleTargets(command, argv, cwd) {
+    const moduleArgIndex = dailyActionModuleArgIndex(command);
+    if (moduleArgIndex === undefined) {
+        return [...argv];
+    }
+    const moduleArg = argv[moduleArgIndex];
+    if (!moduleArg || moduleArg.startsWith('-')) {
+        return [...argv];
+    }
+    const modules = await listModulesInEnvironment(cwd);
+    if (modules.length === 0) {
+        return [...argv];
+    }
+    const resolvedModuleNames = moduleArg.split(',').map((query) => {
+        const trimmedQuery = query.trim();
+        const resolution = resolveModuleTarget(trimmedQuery, modules);
+        if (resolution.kind !== 'exact') {
+            throw moduleTargetResolutionError(resolution);
+        }
+        return resolution.module.moduleName;
+    });
+    const resolvedArgv = [...argv];
+    resolvedArgv[moduleArgIndex] = resolvedModuleNames.join(',');
+    return resolvedArgv;
+}
 async function selectDatabaseArg(cwd, message, fallback, options = {}) {
     const databaseResult = normalizeDatabaseListResult(await listEnvironmentDatabases(cwd, options));
     const databases = databaseResult.databases;
@@ -1585,7 +1636,7 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
     }
     if (isDailyActionCommand(route.command)) {
         console.log(renderBanner());
-        await runDailyAction(route.command, route.argv, cwd);
+        await runDailyAction(route.command, await resolveDailyActionModuleTargets(route.command, route.argv, cwd), cwd);
         return;
     }
     const options = optionsFromArgs(route.argv);

package/dist/cockpit/daily-prompts.js

@@ -83,6 +83,18 @@ async function optionalTextArg(deps, message, fallback) {
         placeholder: fallback,
     }), fallback, deps);
 }
+async function optionalTextArgOrUndefined(deps, message, placeholder) {
+    const value = await deps.text({
+        message: menuPromptMessage(message, 'back'),
+        placeholder,
+    });
+    deps.handleCancel(value, 'back');
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+}
 async function databaseArg(cwd, deps, message, fallback, options = {}) {
     const databaseResult = normalizeDatabaseListResult(await deps.databases(cwd, options));
     const databases = databaseResult.databases;
@@ -139,7 +151,9 @@ export async function collectDailyActionArgs(command, cwd, promptDepsArg = {}) {
         return [];
     }
     if (command === 'logs') {
-        return [await optionalTextArg(deps, 'Service', 'odoo')];
+        const service = await optionalTextArg(deps, 'Service', 'odoo');
+        const tail = await optionalTextArgOrUndefined(deps, 'Tail line count (optional)', '100');
+        return tail ? [service, tail] : [service];
     }
     if (command === 'psql') {
         return [await databaseArg(cwd, deps, 'Database', 'postgres', { includeMaintenance: true })];

package/dist/daily-actions.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { readEnvFile, selectedComposeEnvironment } from './compose-layout.js';
+import { normalizeDatabaseName } from './databases.js';
 import { markerPath } from './environment.js';
 export const dailyActionCommands = [
     'start',
@@ -49,7 +50,7 @@ function usage(command) {
     if (command === 'stop')
         return 'Usage: wpmoo stop';
     if (command === 'logs')
-        return 'Usage: wpmoo logs [service]';
+        return 'Usage: wpmoo logs [service] [tail-lines]';
     if (command === 'restart')
         return 'Usage: wpmoo restart';
     if (command === 'shell')
@@ -86,7 +87,7 @@ function moduleArgs(command, argv) {
     const [modules, db, ...rest] = argv;
     if (!modules || modules.startsWith('-') || rest.length > 0)
         throw new Error(usage(command));
-    return db ? [modules, db] : [modules];
+    return db ? [modules, normalizeDatabaseName(db)] : [modules];
 }
 function positionalArgs(command, argv, min, max) {
     if (argv.length < min || argv.length > max || argv.some((arg) => arg.startsWith('-'))) {
@@ -94,6 +95,32 @@ function positionalArgs(command, argv, min, max) {
     }
     return argv;
 }
+function logsArgs(argv) {
+    if (argv.length > 2 || argv.some((arg) => arg.startsWith('-'))) {
+        throw new Error(usage('logs'));
+    }
+    const [service = 'odoo', tail] = argv;
+    if (tail === undefined) {
+        return [service];
+    }
+    if (!/^[1-9][0-9]*$/u.test(tail)) {
+        throw new Error('Invalid logs tail count: expected a positive integer.');
+    }
+    return [service, tail];
+}
+function validateDatabaseArg(args, index) {
+    if (args[index] === undefined) {
+        return args;
+    }
+    const nextArgs = [...args];
+    nextArgs[index] = normalizeDatabaseName(nextArgs[index]);
+    return nextArgs;
+}
+function rejectLeadingHyphenDatabaseArg(args) {
+    if (args[0]?.startsWith('-')) {
+        normalizeDatabaseName(args[0]);
+    }
+}
 function restoreSnapshotArgs(argv) {
     const args = [...argv];
     const dryRun = args[0] === '--dry-run';
@@ -103,7 +130,8 @@ function restoreSnapshotArgs(argv) {
     if (args.length < 1 || args.length > 2 || args.some((arg) => arg.startsWith('-'))) {
         throw new Error(usage('restore-snapshot'));
     }
-    return dryRun ? ['--dry-run', ...args] : args;
+    const validatedArgs = args.length === 2 ? validateDatabaseArg(args, 1) : args;
+    return dryRun ? ['--dry-run', ...validatedArgs] : validatedArgs;
 }
 function testArgs(argv) {
     const [modules, ...rest] = argv;
@@ -119,6 +147,9 @@ function testArgs(argv) {
         if (option === '--mode' && value !== 'auto' && value !== 'init' && value !== 'update') {
             throw new Error('Invalid value for --mode: expected auto, init, or update');
         }
+        if (option === '--db') {
+            normalizeDatabaseName(value);
+        }
         index += 1;
     }
     return argv;
@@ -129,26 +160,30 @@ function scriptArgs(command, argv) {
     if (command === 'stop')
         return ensureNoArgs(command, argv);
     if (command === 'logs')
-        return optionalSingleArg(command, argv, 'odoo');
+        return logsArgs(argv);
     if (command === 'restart')
         return ensureNoArgs(command, argv);
     if (command === 'shell')
         return ensureNoArgs(command, argv);
     if (command === 'psql')
-        return optionalSingleArg(command, argv, 'postgres');
+        return optionalSingleArg(command, argv, 'postgres').map(normalizeDatabaseName);
     if (command === 'install' || command === 'update')
         return moduleArgs(command, argv);
     if (command === 'test')
         return testArgs(argv);
-    if (command === 'resetdb')
-        return positionalArgs(command, argv, 0, 2);
-    if (command === 'snapshot')
-        return positionalArgs(command, argv, 0, 2);
+    if (command === 'resetdb') {
+        rejectLeadingHyphenDatabaseArg(argv);
+        return validateDatabaseArg(positionalArgs(command, argv, 0, 2), 0);
+    }
+    if (command === 'snapshot') {
+        rejectLeadingHyphenDatabaseArg(argv);
+        return validateDatabaseArg(positionalArgs(command, argv, 0, 2), 0);
+    }
     if (command === 'restore-snapshot')
         return restoreSnapshotArgs(argv);
     if (command === 'lint')
         return ensureNoArgs(command, argv);
-    return positionalArgs(command, argv, 1, 3);
+    return validateDatabaseArg(positionalArgs(command, argv, 1, 3), 1);
 }
 function isDestructiveCommand(command, args) {
     if (command === 'resetdb')
@@ -263,6 +298,12 @@ function renderDailyActionOutputLine(line) {
     if (line === "Running as user 'root' is a security risk.") {
         return `${ANSI_DIM_INFO}${line}${ANSI_RESET}`;
     }
+    if (line.includes('psycopg2.OperationalError')) {
+        return [
+            line,
+            `${ANSI_DIM_INFO}NOTE: PostgreSQL connection failed. Check ./moo status, database service readiness, and credentials before retrying.${ANSI_RESET}`,
+        ].join('\n');
+    }
     return line;
 }
 export function renderDailyActionOutput(output) {

package/dist/databases.js

@@ -1,5 +1,29 @@
 import { spawn } from 'node:child_process';
 const maintenanceDatabases = new Set(['postgres']);
+const databaseNamePattern = /^[A-Za-z0-9_.-]+$/u;
+export function isValidDatabaseName(value) {
+    const normalized = value.trim();
+    return (normalized.length > 0 &&
+        !normalized.startsWith('-') &&
+        databaseNamePattern.test(normalized) &&
+        !/\s/u.test(value));
+}
+export function normalizeDatabaseName(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error('Invalid database name: value is required.');
+    }
+    if (/\s/u.test(value)) {
+        throw new Error('Invalid database name: whitespace is not allowed.');
+    }
+    if (normalized.startsWith('-')) {
+        throw new Error('Invalid database name: leading hyphens are not allowed.');
+    }
+    if (!databaseNamePattern.test(normalized)) {
+        throw new Error('Invalid database name: use letters, digits, underscores, dots, or hyphens without shell metacharacters or path characters.');
+    }
+    return normalized;
+}
 const listDatabasesQuery = [
     'SELECT datname',
     'FROM pg_database',

package/dist/help.js

@@ -24,7 +24,7 @@ Usage:
   npx @wpmoo/toolkit doctor --json [--postgres]
   npx @wpmoo/toolkit start
   npx @wpmoo/toolkit stop
-  npx @wpmoo/toolkit logs [service]
+  npx @wpmoo/toolkit logs [service] [tail-lines]
   npx @wpmoo/toolkit restart
   npx @wpmoo/toolkit shell
   npx @wpmoo/toolkit psql [db]
@@ -148,7 +148,7 @@ Task recipes:
     npx @wpmoo/toolkit status
     npx @wpmoo/toolkit doctor
     npx @wpmoo/toolkit doctor --fix
-    npx @wpmoo/toolkit logs [service]
+    npx @wpmoo/toolkit logs [service] [tail-lines]
     npx @wpmoo/toolkit restart
 
 Machine-readable JSON output:

package/dist/module-manifest.js

@@ -0,0 +1,298 @@
+function createParserState(content) {
+    return {
+        content,
+        parser: {
+            index: 0,
+            line: 1,
+            column: 1,
+        },
+    };
+}
+function makeError(state, message) {
+    return { message, index: state.index, line: state.line, column: state.column };
+}
+function throwParseError(state, message) {
+    const { line, column } = makeError(state, message);
+    throw new Error(`Parse error at ${line}:${column}: ${message}`);
+}
+function isWhitespace(char) {
+    return /\s/u.test(char);
+}
+function peek(state, content, offset = 0) {
+    return content[state.index + offset] ?? '';
+}
+function consumeChar(state, content) {
+    const char = peek(state, content);
+    if (char === '') {
+        return '';
+    }
+    state.index += 1;
+    if (char === '\n') {
+        state.line += 1;
+        state.column = 1;
+    }
+    else {
+        state.column += 1;
+    }
+    return char;
+}
+function skipWhitespaceAndComments(state, content) {
+    while (state.index < content.length) {
+        const char = peek(state, content);
+        if (isWhitespace(char)) {
+            consumeChar(state, content);
+            continue;
+        }
+        if (char === '#') {
+            while (state.index < content.length && peek(state, content) !== '\n') {
+                consumeChar(state, content);
+            }
+            continue;
+        }
+        break;
+    }
+}
+function parseString(state, content) {
+    const quote = consumeChar(state, content);
+    const chars = [];
+    while (state.index < content.length) {
+        const char = consumeChar(state, content);
+        if (char === '\\') {
+            const escaped = consumeChar(state, content);
+            if (!escaped) {
+                throwParseError(state, 'unterminated string escape');
+            }
+            if (escaped === 'n') {
+                chars.push('\n');
+            }
+            else if (escaped === 'r') {
+                chars.push('\r');
+            }
+            else if (escaped === 't') {
+                chars.push('\t');
+            }
+            else if (escaped === quote) {
+                chars.push(quote);
+            }
+            else if (escaped === '\\') {
+                chars.push('\\');
+            }
+            else {
+                chars.push(escaped);
+            }
+            continue;
+        }
+        if (char === quote) {
+            return chars.join('');
+        }
+        if (char === '\n' || char === '\r') {
+            throwParseError(state, 'unterminated string literal');
+        }
+        chars.push(char);
+    }
+    throwParseError(state, 'unterminated string literal');
+}
+function parseIdentifier(state, content) {
+    const chars = [];
+    const start = state.index;
+    const first = peek(state, content);
+    if (!/[A-Za-z_]/u.test(first)) {
+        throwParseError(state, 'expected identifier');
+    }
+    chars.push(consumeChar(state, content));
+    while (state.index < content.length) {
+        const char = peek(state, content);
+        if (/[A-Za-z0-9_]/u.test(char)) {
+            chars.push(consumeChar(state, content));
+            continue;
+        }
+        break;
+    }
+    if (chars.length === 0) {
+        throwParseError(state, 'expected identifier at ' + start);
+    }
+    return chars.join('');
+}
+function parseNumber(state, content) {
+    const chars = [];
+    if (peek(state, content) === '-') {
+        chars.push(consumeChar(state, content));
+    }
+    while (/[0-9]/u.test(peek(state, content))) {
+        chars.push(consumeChar(state, content));
+    }
+    if (peek(state, content) === '.') {
+        chars.push(consumeChar(state, content));
+        if (!/[0-9]/u.test(peek(state, content))) {
+            throwParseError(state, 'invalid numeric literal');
+        }
+        while (/[0-9]/u.test(peek(state, content))) {
+            chars.push(consumeChar(state, content));
+        }
+    }
+    const value = Number(chars.join(''));
+    if (!Number.isFinite(value)) {
+        throwParseError(state, 'invalid numeric literal');
+    }
+    return value;
+}
+function parseValue(state, content) {
+    skipWhitespaceAndComments(state, content);
+    const char = peek(state, content);
+    if (char === '{') {
+        return parseObject(state, content);
+    }
+    if (char === '[') {
+        return parseList(state, content);
+    }
+    if (char === '"' || char === "'") {
+        return parseString(state, content);
+    }
+    if (char === '-' || /[0-9]/u.test(char)) {
+        return parseNumber(state, content);
+    }
+    if (/[A-Za-z_]/u.test(char)) {
+        const identifier = parseIdentifier(state, content);
+        if (identifier === 'True')
+            return true;
+        if (identifier === 'False')
+            return false;
+        if (identifier === 'None')
+            return undefined;
+        throwParseError(state, `unsupported identifier '${identifier}'`);
+    }
+    throwParseError(state, `unexpected character '${char || 'EOF'}'`);
+}
+function expectChar(state, content, expected) {
+    skipWhitespaceAndComments(state, content);
+    const char = consumeChar(state, content);
+    if (char !== expected) {
+        throwParseError(state, `expected '${expected}' but found '${char || 'EOF'}'`);
+    }
+}
+function parseList(state, content) {
+    expectChar(state, content, '[');
+    const values = [];
+    skipWhitespaceAndComments(state, content);
+    if (peek(state, content) === ']') {
+        consumeChar(state, content);
+        return values;
+    }
+    while (state.index < content.length) {
+        const value = parseValue(state, content);
+        values.push(value);
+        skipWhitespaceAndComments(state, content);
+        if (peek(state, content) === ',') {
+            consumeChar(state, content);
+            skipWhitespaceAndComments(state, content);
+            if (peek(state, content) === ']') {
+                consumeChar(state, content);
+                return values;
+            }
+            continue;
+        }
+        if (peek(state, content) === ']') {
+            consumeChar(state, content);
+            return values;
+        }
+        throwParseError(state, "expected ',' or ']'");
+    }
+    throwParseError(state, 'unterminated list literal');
+}
+function parseObject(state, content) {
+    expectChar(state, content, '{');
+    const manifest = {};
+    skipWhitespaceAndComments(state, content);
+    if (peek(state, content) === '}') {
+        consumeChar(state, content);
+        return manifest;
+    }
+    while (state.index < content.length) {
+        skipWhitespaceAndComments(state, content);
+        const key = parseManifestKey(state, content);
+        skipWhitespaceAndComments(state, content);
+        expectChar(state, content, ':');
+        const value = parseValue(state, content);
+        manifest[key] = value;
+        skipWhitespaceAndComments(state, content);
+        if (peek(state, content) === ',') {
+            consumeChar(state, content);
+            skipWhitespaceAndComments(state, content);
+            if (peek(state, content) === '}') {
+                consumeChar(state, content);
+                return manifest;
+            }
+            continue;
+        }
+        if (peek(state, content) === '}') {
+            consumeChar(state, content);
+            return manifest;
+        }
+        throwParseError(state, "expected ',' or '}'");
+    }
+    throwParseError(state, 'unterminated object literal');
+}
+function parseManifestKey(state, content) {
+    skipWhitespaceAndComments(state, content);
+    const char = peek(state, content);
+    if (char !== '"' && char !== "'") {
+        throwParseError(state, 'manifest keys must be quoted');
+    }
+    return parseString(state, content);
+}
+function validateManifest(manifest) {
+    if (manifest.name !== undefined && typeof manifest.name !== 'string') {
+        throw new Error('invalid manifest: name must be a string');
+    }
+    if (manifest.version !== undefined && typeof manifest.version !== 'string') {
+        throw new Error('invalid manifest: version must be a string');
+    }
+    if (manifest.license !== undefined && typeof manifest.license !== 'string') {
+        throw new Error('invalid manifest: license must be a string');
+    }
+    if (manifest.application !== undefined && typeof manifest.application !== 'boolean') {
+        throw new Error('invalid manifest: application must be a boolean');
+    }
+    if (manifest.installable !== undefined && typeof manifest.installable !== 'boolean') {
+        throw new Error('invalid manifest: installable must be a boolean');
+    }
+    if (manifest.depends !== undefined && !Array.isArray(manifest.depends)) {
+        throw new Error('invalid manifest: depends must be a list of strings');
+    }
+    if (manifest.data !== undefined && !Array.isArray(manifest.data)) {
+        throw new Error('invalid manifest: data must be a list of strings');
+    }
+    if (Array.isArray(manifest.depends) && !manifest.depends.every((entry) => typeof entry === 'string')) {
+        throw new Error('invalid manifest: depends must be a list of strings');
+    }
+    if (Array.isArray(manifest.data) && !manifest.data.every((entry) => typeof entry === 'string')) {
+        throw new Error('invalid manifest: data must be a list of strings');
+    }
+    return manifest;
+}
+export function parseOdooManifest(content) {
+    try {
+        const { content: sourceContent, parser } = createParserState(content);
+        const manifest = parseValue(parser, sourceContent);
+        if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+            return { ok: false, error: 'Invalid manifest: top-level value must be a dictionary literal' };
+        }
+        skipWhitespaceAndComments(parser, sourceContent);
+        if (parser.index < sourceContent.length) {
+            return {
+                ok: false,
+                error: `Invalid manifest: trailing content after top-level object at line ${parser.line}, column ${parser.column}`,
+            };
+        }
+        return {
+            ok: true,
+            manifest: validateManifest(manifest),
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return { ok: false, error: error.message };
+        }
+        return { ok: false, error: 'Invalid manifest content' };
+    }
+}