@wpmoo/toolkit 0.9.0

package/dist/doctor.js

@@ -0,0 +1,519 @@
+import { access, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execa } from 'execa';
+import { detectComposeLayout, readEnvFile, selectedComposeEnvironment } from './compose-layout.js';
+import { dailyActionScripts } from './daily-actions.js';
+import { defaultPostgresVersion } from './external-templates.js';
+import { defaultOdooVersion, markerPath, replaceSourceRepos } from './environment.js';
+import { listGitmoduleSources, readSourceManifest, sourceReposFromManifest, sourceManifestPath, syncManifestFromMetadataAndGitmodules, writeSourceManifest, } from './source-manifest.js';
+const realCommandRunner = async (command, args, options) => {
+    const result = await execa(command, args, { cwd: options.cwd });
+    return { stdout: result.stdout, stderr: result.stderr };
+};
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function commandErrorText(error) {
+    const parts = [errorMessage(error)];
+    if (isRecord(error)) {
+        for (const key of ['stderr', 'stdout']) {
+            const value = error[key];
+            if (typeof value === 'string' && value.trim()) {
+                parts.push(value.trim());
+            }
+        }
+    }
+    return parts.join('\n');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(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)
+        return undefined;
+    const trimmed = value.trim();
+    if (/^\d{1,3}$/.test(trimmed)) {
+        return trimmed;
+    }
+    const match = trimmed.match(/postgres:([0-9]{1,3})(?:[-._][A-Za-z0-9._-]+)?(?:@[\w:.-]+)?/i);
+    return match?.[1];
+}
+function stripInlineComment(line) {
+    const hashIndex = line.indexOf('#');
+    if (hashIndex === -1)
+        return line;
+    return line.slice(0, hashIndex);
+}
+function hasInvalidPostgres18Mount(line, mountTarget) {
+    const escaped = mountTarget.replaceAll('.', '\\.').replaceAll('/', '\\/');
+    const shortPatterns = [
+        new RegExp(`^\\s*-\\s+.+:\\s*['"]?${escaped}['"]?(?:\\s|:|$)`),
+        new RegExp(`^\\s*-\\s*['"]?${escaped}['"]?(?:\\s|$)`),
+        new RegExp(`^\\s*target:\\s*['"]?${escaped}['"]?(?:\\s|$)`),
+    ];
+    return shortPatterns.some((pattern) => pattern.test(line));
+}
+function isNonAmbiguousLineForMountFix(line, mountTarget) {
+    return hasInvalidPostgres18Mount(line, mountTarget);
+}
+function replaceMountTargetInLine(line, from, to) {
+    return line.split(from).join(to);
+}
+function normalizePostgres18MountTargetsInComposeContent(content) {
+    const fixedTargets = [];
+    const fixed = [];
+    const hasTrailingNewline = content.endsWith('\n');
+    const comparableContent = hasTrailingNewline ? content.slice(0, -1) : content;
+    const lines = comparableContent.split(/\r?\n/);
+    const nextLines = [];
+    for (const line of lines) {
+        const commentIndex = line.indexOf('#');
+        const comment = commentIndex === -1 ? '' : line.slice(commentIndex);
+        const body = commentIndex === -1 ? line : line.slice(0, commentIndex);
+        let nextBody = body;
+        let lineFixed = false;
+        for (const target of incompatiblePostgres18MountTargets) {
+            if (!isNonAmbiguousLineForMountFix(body, target))
+                continue;
+            nextBody = replaceMountTargetInLine(nextBody, target, '/var/lib/postgresql');
+            if (!fixedTargets.includes(target)) {
+                fixedTargets.push(target);
+            }
+            lineFixed = true;
+        }
+        if (lineFixed) {
+            fixed.push(line);
+            nextLines.push(`${nextBody}${comment}`);
+        }
+        else {
+            nextLines.push(line);
+        }
+    }
+    return {
+        content: `${nextLines.join('\n')}${hasTrailingNewline ? '\n' : ''}`,
+        fixed,
+        fixedTargets,
+    };
+}
+function invalidPostgres18MountTargetsInCompose(content) {
+    const badTargets = new Set();
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = stripInlineComment(rawLine).trim();
+        if (!line)
+            continue;
+        for (const target of incompatiblePostgres18MountTargets) {
+            if (hasInvalidPostgres18Mount(line, target)) {
+                badTargets.add(target);
+            }
+        }
+    }
+    return [...badTargets];
+}
+function inferPostgresVersion(metadata, odooVersion, env) {
+    const envPostgresImage = env?.get('POSTGRES_IMAGE')?.trim();
+    const envPostgresMajor = parsePostgresMajorFromValue(envPostgresImage);
+    if (envPostgresMajor) {
+        return envPostgresMajor;
+    }
+    const explicitPostgres = parsePostgresMajorFromValue(metadataString(metadata, 'postgresVersion'));
+    if (explicitPostgres) {
+        return explicitPostgres;
+    }
+    return defaultPostgresVersion(odooVersion);
+}
+function normalizeSourceType(value) {
+    if (value === 'oca' || value === 'external' || value === 'private') {
+        return value;
+    }
+    return 'private';
+}
+function sourceRepoPath(type, path) {
+    return `odoo/custom/src/${type}/${path}`;
+}
+function entryKey(type, path) {
+    return `${type}:${path}`;
+}
+function sourceReposFromMetadata(metadata) {
+    const sourceRepos = metadata.sourceRepos;
+    if (!Array.isArray(sourceRepos))
+        return [];
+    return sourceRepos
+        .map((repo, index) => {
+        if (!isRecord(repo) || typeof repo.path !== 'string' || !repo.path.trim()) {
+            throw new Error(`Invalid sourceRepos entry in .wpmoo/odoo.json at index ${index}`);
+        }
+        return {
+            url: typeof repo.url === 'string' ? repo.url : '',
+            path: repo.path.trim(),
+            addons: Array.isArray(repo.addons)
+                ? repo.addons.filter((addon) => typeof addon === 'string')
+                : [],
+            sourceType: normalizeSourceType(repo.sourceType),
+        };
+    })
+        .filter((repo) => repo.path)
+        .sort((left, right) => {
+        const typeOrder = left.sourceType.localeCompare(right.sourceType);
+        if (typeOrder !== 0)
+            return typeOrder;
+        return left.path.localeCompare(right.path);
+    });
+}
+async function readMetadata(target) {
+    let content;
+    try {
+        content = await readFile(join(target, markerPath), 'utf8');
+    }
+    catch {
+        throw new Error(`Missing metadata file: ${markerPath}`);
+    }
+    try {
+        const parsed = JSON.parse(content);
+        if (!isRecord(parsed)) {
+            throw new Error('metadata is not an object');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Invalid metadata JSON in ${markerPath}: ${errorMessage(error)}`);
+    }
+}
+function metadataString(metadata, key) {
+    const value = metadata[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function validatePort(name, env, errors) {
+    const value = env.get(name)?.trim() ?? '';
+    if (!/^\d+$/.test(value)) {
+        errors.push(`Invalid ${name} in .env: expected a non-empty numeric value`);
+    }
+    return value;
+}
+function renderFailure(errors) {
+    return ['WPMoo doctor failed:', ...errors.map((error) => `- ${error}`)].join('\n');
+}
+function isNotGitCheckoutError(error) {
+    return commandErrorText(error).toLowerCase().includes('not a git repository');
+}
+function isSourceRepoSubmodule(path, sourceRepos) {
+    return sourceRepos.some((repo) => {
+        const sourcePath = sourceRepoPath(repo.sourceType ?? 'private', repo.path);
+        return path === sourcePath || path.startsWith(`${sourcePath}/`);
+    });
+}
+function sourceSubmoduleStatusErrors(output, sourceRepos) {
+    const errors = [];
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trimEnd();
+        if (!line)
+            continue;
+        const status = line[0];
+        const parts = line.slice(1).trim().split(/\s+/);
+        const path = parts[1];
+        if (!path || !isSourceRepoSubmodule(path, sourceRepos))
+            continue;
+        if (status === '-') {
+            errors.push(`Uninitialized Git submodule: ${path}`);
+        }
+        else if (status === 'U') {
+            errors.push(`Conflicted Git submodule: ${path}`);
+        }
+    }
+    return errors;
+}
+function manifestEntryToKey(entry) {
+    return entryKey(entry.type, entry.path);
+}
+function manifestRepoToKey(repo) {
+    return entryKey(normalizeSourceType(repo.sourceType), repo.path);
+}
+function formatKeyForPath(key) {
+    const [sourceType, ...pathParts] = key.split(':');
+    return sourceRepoPath(sourceType, pathParts.join(':'));
+}
+function checkSourceConsistency(sourceRepos, manifestEntries, gitmoduleSources, manifestExists, gitmodulesExists) {
+    if (!manifestExists) {
+        return [];
+    }
+    const errors = [];
+    const metadataEntries = new Map();
+    for (const repo of sourceRepos) {
+        metadataEntries.set(manifestRepoToKey(repo), repo);
+    }
+    const manifestMap = new Map();
+    for (const entry of manifestEntries) {
+        manifestMap.set(manifestEntryToKey(entry), entry);
+    }
+    const gitmoduleSet = new Set(gitmoduleSources.map((source) => manifestEntryToKey({ type: source.type, path: source.path })));
+    const sortedMetadataKeys = [...metadataEntries.keys()].sort();
+    const sortedManifestKeys = [...manifestMap.keys()].sort();
+    for (const key of sortedMetadataKeys) {
+        if (!manifestMap.has(key)) {
+            errors.push(`Metadata source entry missing in manifest: ${formatKeyForPath(key)}`);
+        }
+    }
+    for (const key of sortedManifestKeys) {
+        if (!metadataEntries.has(key)) {
+            errors.push(`Manifest source entry missing in metadata: ${formatKeyForPath(key)}`);
+        }
+        if (gitmodulesExists && !gitmoduleSet.has(key)) {
+            errors.push(`Manifest source path missing in .gitmodules: ${formatKeyForPath(key)}`);
+        }
+    }
+    return errors;
+}
+async function repairSourceManifestFromDiscoveredState(target, sourceRepos, fallbackBranch, gitmoduleSources) {
+    const entries = syncManifestFromMetadataAndGitmodules(sourceRepos, fallbackBranch, gitmoduleSources);
+    await writeSourceManifest(target, entries);
+    await replaceSourceRepos(target, sourceReposFromManifest(entries));
+}
+export async function getDoctorReport(target = process.cwd(), runnerOrOptions = realCommandRunner, options = {}) {
+    const actualRunner = isDoctorOptions(runnerOrOptions) ? realCommandRunner : runnerOrOptions;
+    const actualOptions = isDoctorOptions(runnerOrOptions) ? runnerOrOptions : options;
+    const errors = [];
+    const warnings = [];
+    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 {
+        checks.push('OK engine compose');
+    }
+    const odooVersion = metadataString(metadata, 'odooVersion') ?? defaultOdooVersion;
+    checks.push(`OK Odoo version ${odooVersion}`);
+    const env = await readEnvFile(target);
+    const composeVersions = new Set([odooVersion]);
+    const envOdooVersion = env?.get('ODOO_VERSION')?.trim();
+    if (envOdooVersion) {
+        composeVersions.add(envOdooVersion);
+    }
+    const composeLayout = await detectComposeLayout(target, {
+        odooVersions: [...composeVersions],
+        envName: selectedComposeEnvironment(env),
+    });
+    if (composeLayout.kind === 'missing') {
+        errors.push(...composeLayout.errors);
+    }
+    else {
+        checks.push(`OK compose files ${composeLayout.files.join(', ')}`);
+        const postgresVersion = inferPostgresVersion(metadata, odooVersion, env);
+        if (postgresVersion === '18') {
+            for (const file of composeLayout.files) {
+                const composePath = join(target, file);
+                let content;
+                try {
+                    content = await readFile(composePath, 'utf8');
+                }
+                catch (error) {
+                    errors.push(`Cannot read compose file for compatibility check: ${file}: ${errorMessage(error)}`);
+                    continue;
+                }
+                if (actualOptions.fix) {
+                    const normalization = normalizePostgres18MountTargetsInComposeContent(content);
+                    if (normalization.fixed.length > 0) {
+                        await writeFile(composePath, normalization.content, 'utf8');
+                        for (const target of normalization.fixedTargets) {
+                            appliedFixes.push(`Normalized PostgreSQL 18 mount target in '${file}': replaced '${target}' -> '/var/lib/postgresql'`);
+                        }
+                        continue;
+                    }
+                }
+                const badMounts = invalidPostgres18MountTargetsInCompose(content);
+                for (const badMount of badMounts) {
+                    errors.push(`PostgreSQL 18 compatibility issue in '${file}': mount target '${badMount}' is invalid; recommend using '/var/lib/postgresql'`);
+                }
+            }
+        }
+    }
+    const scriptNames = Object.values(dailyActionScripts);
+    const scriptErrorCount = errors.length;
+    for (const script of scriptNames) {
+        const relativePath = `scripts/${script}`;
+        if (!(await exists(join(target, relativePath)))) {
+            errors.push(`Missing daily action script: ${relativePath}`);
+        }
+    }
+    if (errors.length === scriptErrorCount) {
+        checks.push(`OK scripts ${scriptNames.length} checked`);
+    }
+    let sourceRepos;
+    try {
+        sourceRepos = sourceReposFromMetadata(metadata);
+    }
+    catch (error) {
+        errors.push(errorMessage(error));
+        return report;
+    }
+    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}`);
+        }
+    }
+    checks.push(`OK source repos ${sourceRepos.length} checked`);
+    const manifestPath = join(target, sourceManifestPath);
+    const hasManifest = await exists(manifestPath);
+    let manifestEntries = [];
+    let manifestReadError;
+    if (hasManifest) {
+        try {
+            manifestEntries = (await readSourceManifest(target)).sources;
+        }
+        catch (error) {
+            manifestReadError = `Failed to read source manifest ${sourceManifestPath}: ${errorMessage(error)}`;
+            if (!actualOptions.fix) {
+                errors.push(manifestReadError);
+            }
+        }
+    }
+    const gitmoduleSources = await listGitmoduleSources(target);
+    const hasGitmodules = await exists(join(target, '.gitmodules'));
+    const sourceConsistencyIssues = !manifestReadError
+        ? checkSourceConsistency(sourceRepos, manifestEntries, gitmoduleSources, hasManifest, hasGitmodules)
+        : [];
+    const shouldSyncSources = actualOptions.fix &&
+        (manifestReadError || sourceConsistencyIssues.length > 0 || (!hasManifest && (sourceRepos.length > 0 || gitmoduleSources.length > 0)));
+    if (sourceConsistencyIssues.length > 0) {
+        if (actualOptions.fix) {
+            const uniqueIssues = [...new Set(sourceConsistencyIssues)];
+            appliedFixes.push(...uniqueIssues.map((issue) => `Will regenerate source manifest and metadata to fix: ${issue}`));
+        }
+        else {
+            errors.push(...sourceConsistencyIssues);
+        }
+    }
+    else if (manifestReadError) {
+        appliedFixes.push('Will regenerate source manifest and metadata after repairing source manifest read failure.');
+    }
+    else if (shouldSyncSources) {
+        appliedFixes.push('Will create missing source manifest from metadata and .gitmodules state.');
+    }
+    if (shouldSyncSources && actualOptions.fix) {
+        await repairSourceManifestFromDiscoveredState(target, sourceRepos, odooVersion, gitmoduleSources);
+        appliedFixes.push('Synced source manifest and metadata with current metadata/.gitmodules state.');
+    }
+    if (env) {
+        const httpPort = validatePort('HTTP_PORT', env, errors);
+        const geventPort = validatePort('GEVENT_PORT', env, errors);
+        if (httpPort && geventPort && httpPort === geventPort) {
+            errors.push('HTTP_PORT and GEVENT_PORT in .env must not be equal');
+        }
+        if (/^\d+$/.test(httpPort) && /^\d+$/.test(geventPort) && httpPort !== geventPort) {
+            checks.push(`OK .env ports HTTP_PORT=${httpPort} GEVENT_PORT=${geventPort}`);
+        }
+    }
+    try {
+        await actualRunner('docker', ['version'], { cwd: target });
+        checks.push('OK docker CLI');
+    }
+    catch (error) {
+        errors.push(`Docker CLI check failed: ${errorMessage(error)}`);
+    }
+    try {
+        await actualRunner('docker', ['compose', 'version'], { cwd: target });
+        checks.push('OK docker compose');
+    }
+    catch (error) {
+        errors.push(`Docker Compose check failed: ${errorMessage(error)}`);
+    }
+    if (sourceRepos.length > 0) {
+        try {
+            const result = await actualRunner('git', ['submodule', 'status', '--recursive'], { cwd: target });
+            const submoduleErrors = sourceSubmoduleStatusErrors(result.stdout, sourceRepos);
+            errors.push(...submoduleErrors);
+            if (submoduleErrors.length === 0) {
+                checks.push(`OK git submodules ${sourceRepos.length} checked`);
+            }
+        }
+        catch (error) {
+            if (isNotGitCheckoutError(error)) {
+                checks.push('OK git submodules skipped (not a git checkout)');
+            }
+            else {
+                errors.push(`Git submodule status check failed: ${errorMessage(error)}`);
+            }
+        }
+    }
+    try {
+        await actualRunner('gh', ['auth', 'status'], { cwd: target });
+        checks.push('OK GitHub CLI auth');
+    }
+    catch (error) {
+        warnings.push(`GitHub CLI auth: ${errorMessage(error)}`);
+    }
+    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.',
+                ...report.appliedFixes.map((fix) => `- ${fix}`),
+                renderFailure(report.errors),
+            ].join('\n');
+        }
+        throw new Error(renderFailure(report.errors));
+    }
+    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:',
+            ...report.appliedFixes.map((fix) => `- ${fix}`),
+            '',
+            postFixReport,
+        ].join('\n');
+    }
+    return renderedReport.join('\n');
+}

package/dist/environment-context.js

@@ -0,0 +1,10 @@
+import { readEnvironmentMetadata } from './environment.js';
+import { inferGitHubOwner } from './repo-url.js';
+export async function environmentGitHubOwner(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    return inferGitHubOwner(metadata?.devRepoUrl ?? '');
+}
+export async function environmentProduct(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    return metadata?.product;
+}

package/dist/environment-version.js

@@ -0,0 +1,5 @@
+import { environmentOdooVersion } from './environment.js';
+export async function commandOdooVersion(target, explicitVersion) {
+    const normalizedVersion = explicitVersion?.trim();
+    return normalizedVersion || environmentOdooVersion(target);
+}

package/dist/environment.js

@@ -0,0 +1,136 @@
+import { access, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { packageName, packageVersion } from './version.js';
+const validSourceTypes = ['private', 'oca', 'external'];
+export const markerPath = '.wpmoo/odoo.json';
+export const defaultOdooVersion = '19.0';
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function environmentMetadata(options) {
+    return {
+        tool: packageName(),
+        version: packageVersion(),
+        product: options.product,
+        odooVersion: options.odooVersion,
+        devRepo: options.devRepo,
+        devRepoUrl: options.devRepoUrl,
+        sourceRepos: options.sourceRepos,
+        engine: options.engine ?? 'compose',
+        composeTemplateUrl: options.composeTemplateUrl,
+        composeTemplateRef: options.composeTemplateRef,
+        agentSkillsTemplateUrl: options.agentSkillsTemplateUrl,
+        agentSkillsTemplateRef: options.agentSkillsTemplateRef,
+        postgresVersion: options.postgresVersion,
+        httpPort: options.httpPort,
+        geventPort: options.geventPort,
+    };
+}
+export function renderEnvironmentMetadata(options) {
+    return `${JSON.stringify(environmentMetadata(options), null, 2)}\n`;
+}
+function normalizeSourceType(sourceType) {
+    const normalized = sourceType ?? 'private';
+    return validSourceTypes.includes(normalized) ? normalized : 'private';
+}
+function normalizeMetadataSourceRepo(repo) {
+    if (!repo || typeof repo !== 'object') {
+        return undefined;
+    }
+    const candidate = repo;
+    const path = typeof candidate.path === 'string' ? candidate.path : '';
+    const url = typeof candidate.url === 'string' ? candidate.url : '';
+    const addons = Array.isArray(candidate.addons) ? candidate.addons.filter((item) => typeof item === 'string') : [];
+    const sourceType = normalizeSourceType(typeof candidate.sourceType === 'string' ? candidate.sourceType : undefined);
+    if (!path) {
+        return undefined;
+    }
+    return { ...candidate, path, url, addons, sourceType };
+}
+function sourceRepoWithType(repo) {
+    return {
+        ...repo,
+        sourceType: normalizeSourceType(repo.sourceType),
+    };
+}
+function withoutPathDuplicates(repos) {
+    const byPath = new Map();
+    repos.forEach((repo) => {
+        const normalized = sourceRepoWithType(repo);
+        byPath.set(`${normalized.sourceType}:${normalized.path}`, normalized);
+    });
+    return Array.from(byPath.values());
+}
+export async function readEnvironmentMetadata(target) {
+    try {
+        const content = await readFile(join(target, markerPath), 'utf8');
+        const metadata = JSON.parse(content);
+        if (!metadata?.sourceRepos || !Array.isArray(metadata.sourceRepos)) {
+            return metadata;
+        }
+        metadata.sourceRepos = metadata.sourceRepos
+            .map(normalizeMetadataSourceRepo)
+            .filter((repo) => Boolean(repo));
+        metadata.sourceRepos = withoutPathDuplicates(metadata.sourceRepos);
+        return metadata;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function writeEnvironmentMetadata(target, metadata) {
+    const content = `${JSON.stringify({
+        ...metadata,
+        sourceRepos: metadata.sourceRepos.map(sourceRepoWithType),
+    }, null, 2)}\n`;
+    await writeFile(join(target, markerPath), content, 'utf8');
+}
+export async function replaceSourceRepos(target, sourceRepos) {
+    const metadata = await readEnvironmentMetadata(target);
+    if (!metadata)
+        return;
+    metadata.sourceRepos = withoutPathDuplicates(sourceRepos.map((repo) => sourceRepoWithType(repo)));
+    await writeEnvironmentMetadata(target, metadata);
+}
+export async function upsertSourceRepoMetadata(target, sourceRepo) {
+    const metadata = await readEnvironmentMetadata(target);
+    if (!metadata)
+        return;
+    const normalizedRepo = sourceRepoWithType(sourceRepo);
+    const sources = metadata.sourceRepos.filter((repo) => !(repo.path === normalizedRepo.path && normalizeSourceType(repo.sourceType) === normalizedRepo.sourceType));
+    sources.push(normalizedRepo);
+    metadata.sourceRepos = withoutPathDuplicates(sources);
+    await writeEnvironmentMetadata(target, metadata);
+}
+export async function removeSourceRepoMetadata(target, repoPath, sourceType) {
+    const metadata = await readEnvironmentMetadata(target);
+    if (!metadata)
+        return;
+    const normalizedType = normalizeSourceType(sourceType);
+    metadata.sourceRepos = metadata.sourceRepos.filter((repo) => !(repo.path === repoPath && normalizeSourceType(repo.sourceType) === normalizedType));
+    await writeEnvironmentMetadata(target, metadata);
+}
+export async function detectDevelopmentEnvironment(target) {
+    if (await readEnvironmentMetadata(target)) {
+        return { isEnvironment: true, source: 'marker' };
+    }
+    const hasAddonsYaml = await exists(join(target, 'odoo/custom/src/addons.yaml'));
+    const hasReposYaml = await exists(join(target, 'odoo/custom/src/repos.yaml'));
+    const hasSourceDir = (await exists(join(target, 'odoo/custom/src/private'))) ||
+        (await exists(join(target, 'odoo/custom/src/oca'))) ||
+        (await exists(join(target, 'odoo/custom/src/external')));
+    if (hasAddonsYaml && hasReposYaml && hasSourceDir) {
+        return { isEnvironment: true, source: 'layout' };
+    }
+    return { isEnvironment: false, source: 'none' };
+}
+export async function environmentOdooVersion(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    return metadata?.odooVersion || defaultOdooVersion;
+}