@wpmoo/odoo 0.8.64 → 0.8.66

package/README.md

@@ -138,8 +138,11 @@ npx @wpmoo/odoo --help
 npx @wpmoo/odoo --version
 
 npx @wpmoo/odoo status
+npx @wpmoo/odoo status --json
 npx @wpmoo/odoo doctor
+npx @wpmoo/odoo doctor --json
 npx @wpmoo/odoo doctor --fix
+npx @wpmoo/odoo source list --json
 npx @wpmoo/odoo add-repo --repo-url https://github.com/example-org/odoo_sample_module_reports.git
 npx @wpmoo/odoo remove-repo --repo odoo_sample_module_reports
 npx @wpmoo/odoo add-module --repo odoo_sample_module --module odoo_sample_module_base --source-type private
@@ -319,12 +322,14 @@ Inspect configured sources:
 
 ```bash
 npx @wpmoo/odoo source list
+npx @wpmoo/odoo source list --json
 ```
 
 Regenerate the manifest and metadata from the current metadata/gitmodule state:
 
 ```bash
 npx @wpmoo/odoo source sync
+npx @wpmoo/odoo source sync --json
 ```
 
 `source add` and `source remove` are direct aliases for the same repository
@@ -344,10 +349,23 @@ npx @wpmoo/odoo source remove --repo server-tools --source-type oca
 
 ```bash
 npx @wpmoo/odoo status
+npx @wpmoo/odoo status --json
 ```
 
 It reports whether the environment is detected, which Odoo version is selected, how many source repos are configured, how many module candidates are present, which core files are missing, and the recommended next action.
 
+For automation and VS Code cockpit integration, all of these commands also support
+`--json`:
+
+```bash
+npx @wpmoo/odoo status --json
+npx @wpmoo/odoo source list --json
+npx @wpmoo/odoo source sync --json
+npx @wpmoo/odoo doctor --json
+```
+
+JSON output is optional; human-readable output remains the default.
+
 `doctor` performs deeper checks:
 
 ```bash

package/dist/cli.js

@@ -12,7 +12,7 @@ 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 { runDoctor } from './doctor.js';
+import { getDoctorReport, runDoctor } from './doctor.js';
 import { getOriginUrl, realGit } from './git.js';
 import { renderHelp } from './help.js';
 import { addModuleToSourceRepo, listModulesInSourceRepo, removeModuleFromSourceRepo, } from './module-actions.js';
@@ -22,13 +22,13 @@ import { promptRepositoryUrl } from './prompt-repositories.js';
 import { inferGitHubOwner, inferRepoPath, normalizeRepositoryUrl } from './repo-url.js';
 import { addModuleRepo, listModuleRepos, removeModuleRepo } from './repo-actions.js';
 import { renderSafeResetPreview, safeResetEnvironment } from './safe-reset.js';
-import { listSources, renderSourceList, syncSources } from './source-actions.js';
+import { listSources, renderSourceList, sourceListJson, sourceSyncJson, syncSources, } from './source-actions.js';
 import { checkGitHubRepositories, createGitHubRepositories, manualCreateCommands, repositoryPreflightAvailable, } from './repository-preflight.js';
 import { scaffold } from './scaffold.js';
 import { renderBanner } from './templates.js';
 import { checkForUpdate, installLatestPackage, isUpdateCheckSkipped, restartCli } from './update-check.js';
 import { packageName, packageVersion, renderVersion, renderVersionTag } from './version.js';
-import { getEnvironmentStatus, renderEnvironmentStatusForTarget, renderEnvironmentStatusSummary, } from './status.js';
+import { environmentStatusJson, getEnvironmentStatus, renderEnvironmentStatusForTarget, renderEnvironmentStatusSummary, } from './status.js';
 import { getGitHubAccounts, getGitHubRepositoryStatus, githubRepositoryUrl, realGitHub, createGitHubRepository, } from './github.js';
 import { environmentGitHubOwner } from './environment-context.js';
 import { handlePromptCancel, handleUnavailableMenuChoice, installPromptCancelKeyTracker, isMenuBackSignal, MenuBackSignal, menuIntroTitle, menuPromptMessage, } from './menu-navigation.js';
@@ -106,6 +106,12 @@ function booleanOption(values, key, fallback) {
         return false;
     throw new Error(`Invalid boolean value for --${key}: ${value}`);
 }
+function jsonOption(values) {
+    return booleanOption(values, 'json', false);
+}
+function printJson(value) {
+    console.log(JSON.stringify(value));
+}
 function yellow(value) {
     if (!process.stdout.isTTY || process.env.NO_COLOR !== undefined)
         return value;
@@ -493,17 +499,19 @@ function resetCommandOptionsFromArgs(argv) {
     };
 }
 function doctorOptionsFromArgs(argv) {
-    if (argv.length === 0) {
-        return {};
-    }
     const { values } = parseArgs(argv);
     const keys = Object.keys(values);
-    if (keys.length !== 1 || !Object.hasOwn(values, 'fix')) {
+    const allowedKeys = new Set(['fix', 'json']);
+    if (!keys.every((key) => allowedKeys.has(key))) {
         throw new Error('Usage: wpmoo doctor');
     }
-    return {
-        fix: booleanOption(values, 'fix', false),
+    const options = {
+        json: jsonOption(values),
     };
+    if (Object.hasOwn(values, 'fix')) {
+        options.fix = booleanOption(values, 'fix', false);
+    }
+    return options;
 }
 function sourceUsage() {
     return 'Usage: wpmoo source <list|sync|add|remove> [options]';
@@ -513,11 +521,15 @@ function sourceSyncOptionsFromArgs(argv) {
     return {
         target: resolve(stringOption(values, 'target') ?? process.cwd()),
         stage: booleanOption(values, 'stage', true),
+        json: jsonOption(values),
     };
 }
-function sourceListTargetFromArgs(argv) {
+function sourceListOptionsFromArgs(argv) {
     const { values } = parseArgs(argv);
-    return resolve(stringOption(values, 'target') ?? process.cwd());
+    return {
+        target: resolve(stringOption(values, 'target') ?? process.cwd()),
+        json: jsonOption(values),
+    };
 }
 async function runSourceCommand(argv) {
     const [subcommand, ...subcommandArgv] = argv;
@@ -525,15 +537,24 @@ async function runSourceCommand(argv) {
         throw new Error(sourceUsage());
     }
     if (subcommand === 'list') {
+        const options = sourceListOptionsFromArgs(subcommandArgv);
+        const sources = await listSources(options.target);
+        if (options.json) {
+            printJson(sourceListJson(sources));
+            return;
+        }
         console.log(renderBanner());
-        const target = sourceListTargetFromArgs(subcommandArgv);
-        console.log(renderSourceList(await listSources(target)));
+        console.log(renderSourceList(sources));
         return;
     }
     if (subcommand === 'sync') {
-        console.log(renderBanner());
         const options = sourceSyncOptionsFromArgs(subcommandArgv);
-        await syncSources(options);
+        const sources = await syncSources({ target: options.target, stage: options.stage });
+        if (options.json) {
+            printJson(sourceSyncJson(sources, options.target));
+            return;
+        }
+        console.log(renderBanner());
         outro(`Synced source manifest in ${options.target}.`);
         return;
     }
@@ -907,14 +928,28 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
     }
     if (route.command === 'doctor') {
         const options = doctorOptionsFromArgs(route.argv);
+        const doctorOptions = {};
+        if (options.fix !== undefined) {
+            doctorOptions.fix = options.fix;
+        }
+        if (options.json) {
+            printJson(await getDoctorReport(cwd, doctorOptions));
+            return;
+        }
         console.log(renderBanner());
-        console.log(options.fix === undefined ? await runDoctor(cwd) : await runDoctor(cwd, options));
+        console.log(options.fix === undefined ? await runDoctor(cwd) : await runDoctor(cwd, doctorOptions));
         return;
     }
     if (route.command === 'status') {
-        if (route.argv.length > 0) {
+        const { values } = parseArgs(route.argv);
+        const keys = Object.keys(values);
+        if (!keys.every((key) => key === 'json')) {
             throw new Error('Usage: wpmoo status');
         }
+        if (jsonOption(values)) {
+            printJson(environmentStatusJson(await getEnvironmentStatus(cwd)));
+            return;
+        }
         console.log(renderBanner());
         console.log(await renderEnvironmentStatusForTarget(cwd));
         return;

package/dist/doctor.js

@@ -40,6 +40,11 @@ function isRecord(value) {
 function isDoctorOptions(value) {
     return isRecord(value);
 }
+function isMetadataError(message) {
+    return (message.startsWith('Missing metadata file:') ||
+        message.startsWith('Invalid metadata JSON in .wpmoo/odoo.json') ||
+        message.startsWith('Invalid sourceRepos entry in .wpmoo/odoo.json'));
+}
 const incompatiblePostgres18MountTargets = ['/var/lib/postgresql/data', '/var/lib/postgresql/18/docker'];
 function parsePostgresMajorFromValue(value) {
     if (!value)
@@ -280,24 +285,41 @@ async function repairSourceManifestFromDiscoveredState(target, sourceRepos, fall
     await writeSourceManifest(target, entries);
     await replaceSourceRepos(target, sourceReposFromManifest(entries));
 }
-export async function runDoctor(target = process.cwd(), runnerOrOptions = realCommandRunner, options = {}) {
+export async function getDoctorReport(target = process.cwd(), runnerOrOptions = realCommandRunner, options = {}) {
     const actualRunner = isDoctorOptions(runnerOrOptions) ? realCommandRunner : runnerOrOptions;
     const actualOptions = isDoctorOptions(runnerOrOptions) ? runnerOrOptions : options;
-    const appliedFixes = [];
-    const lines = ['WPMoo doctor'];
     const errors = [];
     const warnings = [];
-    const metadata = await readMetadata(target);
-    lines.push(`OK metadata ${markerPath}`);
+    const checks = [];
+    const appliedFixes = [];
+    const report = {
+        schemaVersion: 1,
+        command: 'doctor',
+        ok: false,
+        target,
+        checks,
+        warnings,
+        errors,
+        appliedFixes,
+    };
+    let metadata;
+    try {
+        metadata = await readMetadata(target);
+    }
+    catch (error) {
+        errors.push(errorMessage(error));
+        return report;
+    }
+    checks.push(`OK metadata ${markerPath}`);
     const engine = metadataString(metadata, 'engine') ?? 'compose';
     if (engine !== 'compose') {
         errors.push(`Unsupported environment engine: ${engine}`);
     }
     else {
-        lines.push('OK engine compose');
+        checks.push('OK engine compose');
     }
     const odooVersion = metadataString(metadata, 'odooVersion') ?? defaultOdooVersion;
-    lines.push(`OK Odoo version ${odooVersion}`);
+    checks.push(`OK Odoo version ${odooVersion}`);
     const env = await readEnvFile(target);
     const composeVersions = new Set([odooVersion]);
     const envOdooVersion = env?.get('ODOO_VERSION')?.trim();
@@ -312,7 +334,7 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
         errors.push(...composeLayout.errors);
     }
     else {
-        lines.push(`OK compose files ${composeLayout.files.join(', ')}`);
+        checks.push(`OK compose files ${composeLayout.files.join(', ')}`);
         const postgresVersion = inferPostgresVersion(metadata, odooVersion, env);
         if (postgresVersion === '18') {
             for (const file of composeLayout.files) {
@@ -351,16 +373,23 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
         }
     }
     if (errors.length === scriptErrorCount) {
-        lines.push(`OK scripts ${scriptNames.length} checked`);
+        checks.push(`OK scripts ${scriptNames.length} checked`);
+    }
+    let sourceRepos;
+    try {
+        sourceRepos = sourceReposFromMetadata(metadata);
+    }
+    catch (error) {
+        errors.push(errorMessage(error));
+        return report;
     }
-    const sourceRepos = sourceReposFromMetadata(metadata);
     for (const repo of sourceRepos) {
         const relativePath = sourceRepoPath(normalizeSourceType(repo.sourceType), repo.path);
         if (!(await exists(join(target, relativePath))) && repo.path) {
             errors.push(`Missing source repo path: ${relativePath}`);
         }
     }
-    lines.push(`OK source repos ${sourceRepos.length} checked`);
+    checks.push(`OK source repos ${sourceRepos.length} checked`);
     const manifestPath = join(target, sourceManifestPath);
     const hasManifest = await exists(manifestPath);
     let manifestEntries = [];
@@ -409,19 +438,19 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
             errors.push('HTTP_PORT and GEVENT_PORT in .env must not be equal');
         }
         if (/^\d+$/.test(httpPort) && /^\d+$/.test(geventPort) && httpPort !== geventPort) {
-            lines.push(`OK .env ports HTTP_PORT=${httpPort} GEVENT_PORT=${geventPort}`);
+            checks.push(`OK .env ports HTTP_PORT=${httpPort} GEVENT_PORT=${geventPort}`);
         }
     }
     try {
         await actualRunner('docker', ['version'], { cwd: target });
-        lines.push('OK docker CLI');
+        checks.push('OK docker CLI');
     }
     catch (error) {
         errors.push(`Docker CLI check failed: ${errorMessage(error)}`);
     }
     try {
         await actualRunner('docker', ['compose', 'version'], { cwd: target });
-        lines.push('OK docker compose');
+        checks.push('OK docker compose');
     }
     catch (error) {
         errors.push(`Docker Compose check failed: ${errorMessage(error)}`);
@@ -432,12 +461,12 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
             const submoduleErrors = sourceSubmoduleStatusErrors(result.stdout, sourceRepos);
             errors.push(...submoduleErrors);
             if (submoduleErrors.length === 0) {
-                lines.push(`OK git submodules ${sourceRepos.length} checked`);
+                checks.push(`OK git submodules ${sourceRepos.length} checked`);
             }
         }
         catch (error) {
             if (isNotGitCheckoutError(error)) {
-                lines.push('OK git submodules skipped (not a git checkout)');
+                checks.push('OK git submodules skipped (not a git checkout)');
             }
             else {
                 errors.push(`Git submodule status check failed: ${errorMessage(error)}`);
@@ -446,32 +475,45 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
     }
     try {
         await actualRunner('gh', ['auth', 'status'], { cwd: target });
-        lines.push('OK GitHub CLI auth');
+        checks.push('OK GitHub CLI auth');
     }
     catch (error) {
-        warnings.push(`WARN GitHub CLI auth: ${errorMessage(error)}`);
+        warnings.push(`GitHub CLI auth: ${errorMessage(error)}`);
     }
-    if (errors.length > 0) {
-        if (actualOptions.fix && appliedFixes.length > 0) {
+    report.ok = errors.length === 0;
+    return report;
+}
+export async function runDoctor(target = process.cwd(), runnerOrOptions = realCommandRunner, options = {}) {
+    const report = await getDoctorReport(target, runnerOrOptions, options);
+    const actualRunner = isDoctorOptions(runnerOrOptions) ? realCommandRunner : runnerOrOptions;
+    const actualOptions = isDoctorOptions(runnerOrOptions) ? runnerOrOptions : options;
+    if (!report.ok) {
+        if (report.errors.some(isMetadataError)) {
+            throw new Error(report.errors[0]);
+        }
+        if (actualOptions.fix && report.appliedFixes.length > 0) {
             return [
                 'Doctor auto-fixes were not enough to satisfy all checks.',
-                ...appliedFixes.map((fix) => `- ${fix}`),
-                renderFailure(errors),
+                ...report.appliedFixes.map((fix) => `- ${fix}`),
+                renderFailure(report.errors),
             ].join('\n');
         }
-        throw new Error(renderFailure(errors));
+        throw new Error(renderFailure(report.errors));
     }
-    lines.push(...warnings);
-    lines.push('Doctor checks passed.');
-    const report = lines.join('\n');
-    if (actualOptions.fix && appliedFixes.length > 0) {
+    const renderedReport = [
+        'WPMoo doctor',
+        ...report.checks,
+        ...report.warnings.map((warning) => `WARN ${warning}`),
+        'Doctor checks passed.',
+    ];
+    if (report.appliedFixes.length > 0) {
         const postFixReport = await runDoctor(target, actualRunner, { ...actualOptions, fix: false });
         return [
             'Applied safe doctor fixes:',
-            ...appliedFixes.map((fix) => `- ${fix}`),
+            ...report.appliedFixes.map((fix) => `- ${fix}`),
             '',
             postFixReport,
         ].join('\n');
     }
-    return report;
+    return renderedReport.join('\n');
 }

package/dist/external-assets.js

@@ -1,4 +1,4 @@
-import { cp, mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
+import { cp, mkdir, mkdtemp, readdir, rm, stat, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, join, relative, resolve } from 'node:path';
 import { realGit } from './git.js';
@@ -12,6 +12,14 @@ async function pathExists(path) {
         return false;
     }
 }
+async function statIfExists(path) {
+    try {
+        return await stat(path);
+    }
+    catch {
+        return undefined;
+    }
+}
 function expandHome(path) {
     if (path === '~')
         return process.env.HOME ?? path;
@@ -61,6 +69,25 @@ function isExcluded(relativePath, excludes) {
     const normalized = relativePath.split('\\').join('/');
     return excludes.some((pattern) => normalized === pattern || normalized.startsWith(`${pattern}/`));
 }
+async function removeDestinationTypeConflicts(sourcePath, destinationPath, excludes) {
+    async function visit(source) {
+        const rel = relative(sourcePath, source);
+        if (rel && isExcluded(rel, excludes))
+            return;
+        const sourceStat = await stat(source);
+        const destination = rel ? join(destinationPath, rel) : destinationPath;
+        const destinationStat = await statIfExists(destination);
+        if (destinationStat && sourceStat.isDirectory() !== destinationStat.isDirectory()) {
+            await rm(destination, { recursive: true, force: true });
+        }
+        if (!sourceStat.isDirectory()) {
+            return;
+        }
+        const entries = await readdir(source);
+        await Promise.all(entries.map((entry) => visit(join(source, entry))));
+    }
+    await visit(sourcePath);
+}
 async function copyDirectory(options, checkedOut) {
     const selectedSourceSubdir = await selectSourceSubdir(options, checkedOut.root);
     const sourcePath = selectedSourceSubdir ? join(checkedOut.root, selectedSourceSubdir) : checkedOut.root;
@@ -72,6 +99,7 @@ async function copyDirectory(options, checkedOut) {
     }
     const excludes = [...defaultExcludes, ...(options.exclude ?? [])];
     await mkdir(destinationPath, { recursive: true });
+    await removeDestinationTypeConflicts(sourcePath, destinationPath, excludes);
     await cp(sourcePath, destinationPath, {
         recursive: true,
         force: true,

package/dist/help.js

@@ -7,16 +7,20 @@ Usage:
   npx @wpmoo/odoo
   npx @wpmoo/odoo create --product <slug> [--target <path>] --dev-repo-url <url> --source-repo-url <url>
   npx @wpmoo/odoo status
+  npx @wpmoo/odoo status --json
   npx @wpmoo/odoo add-repo --repo-url <url> [--source-type private|oca|external]
   npx @wpmoo/odoo remove-repo --repo <name>
   npx @wpmoo/odoo source list
+  npx @wpmoo/odoo source list --json
   npx @wpmoo/odoo source sync
+  npx @wpmoo/odoo source sync --json
   npx @wpmoo/odoo source add --repo-url <url> [--source-type private|oca|external]
   npx @wpmoo/odoo source remove --repo <name> [--source-type private|oca|external]
   npx @wpmoo/odoo add-module --repo <source-repo> --module <module-name> [--source-type <category>]
   npx @wpmoo/odoo remove-module --repo <source-repo> --module <module-name> [--source-type <category>]
   npx @wpmoo/odoo reset [--dry-run]
   npx @wpmoo/odoo doctor [--fix]
+  npx @wpmoo/odoo doctor --json
   npx @wpmoo/odoo start
   npx @wpmoo/odoo stop
   npx @wpmoo/odoo logs [service]
@@ -48,6 +52,7 @@ Options:
   --postgres-version <value>   PostgreSQL image version written to compose .env.example.
   --http-port <port>           Host HTTP port written to .env.example.
   --gevent-port <port>         Host gevent/live chat port written to .env.example.
+  --json                      Emit machine-readable JSON. Human-readable output remains the default.
   --repo-url <url>             Source repo URL for add-repo.
   --source-type <category>     Source repo category for add-repo/remove-repo/add-module/remove-module. One of private, oca, external. Default: private.
   --repo <name>                Source repo folder name for repo/module actions.
@@ -121,6 +126,13 @@ Task recipes:
     npx @wpmoo/odoo logs [service]
     npx @wpmoo/odoo restart
 
+Machine-readable JSON output:
+  for automation and VS Code cockpit integration while keeping default human-readable output.
+    npx @wpmoo/odoo status --json
+    npx @wpmoo/odoo source list --json
+    npx @wpmoo/odoo source sync --json
+    npx @wpmoo/odoo doctor --json
+
 Example:
   npx @wpmoo/odoo create \\
     --product odoo_sample_module \\

package/dist/source-actions.js

@@ -1,6 +1,12 @@
 import { defaultOdooVersion, readEnvironmentMetadata, replaceSourceRepos } from './environment.js';
 import { realGit, stageAll } from './git.js';
 import { listGitmoduleSources, readSourceManifest, sourceManifestEntriesFromMetadata, sourceReposFromManifest, syncManifestFromMetadataAndGitmodules, writeSourceManifest, } from './source-manifest.js';
+function cloneSourceEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        addons: [...entry.addons],
+    }));
+}
 export async function listSources(target) {
     const metadata = await readEnvironmentMetadata(target);
     const manifest = await readSourceManifest(target);
@@ -24,6 +30,23 @@ export function renderSourceList(entries) {
     })
         .join('\n');
 }
+export function sourceListJson(entries) {
+    return {
+        schemaVersion: 1,
+        command: 'source list',
+        ok: true,
+        sources: cloneSourceEntries(entries),
+    };
+}
+export function sourceSyncJson(entries, target) {
+    return {
+        schemaVersion: 1,
+        command: 'source sync',
+        ok: true,
+        target,
+        sources: cloneSourceEntries(entries),
+    };
+}
 export async function syncSources(options, git = realGit) {
     const metadata = await readEnvironmentMetadata(options.target);
     const manifest = await readSourceManifest(options.target);

package/dist/status.js

@@ -123,6 +123,21 @@ function summaryText(status) {
         : 'Environment ready';
     return `${prefix}: Odoo ${status.odooVersion}, source repos ${status.sourceRepoCount}, module candidates ${status.moduleCandidateCount}.`;
 }
+function isStatusHealthy(status) {
+    if (status.kind !== 'environment')
+        return false;
+    return (status.missingCoreFiles.length === 0 &&
+        status.invalidSourceRepoPaths.length === 0 &&
+        status.composeErrors.length === 0);
+}
+export function environmentStatusJson(status) {
+    return {
+        schemaVersion: 1,
+        command: 'status',
+        ok: isStatusHealthy(status),
+        status,
+    };
+}
 export async function getEnvironmentStatus(target) {
     const metadataFullPath = join(target, markerPath);
     if (!(await pathExists(metadataFullPath))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpmoo/odoo",
-  "version": "0.8.64",
+  "version": "0.8.66",
   "description": "WPMoo Odoo lifecycle tooling for development, staging, and production workflows.",
   "type": "module",
   "repository": {