@open-mova/cli 0.1.9

package/dist/application/shell-repository.js

@@ -0,0 +1,141 @@
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { basename, join } from 'node:path';
+import { tmpdir } from 'node:os';
+export const SHELL_REPOSITORY = 'https://github.com/rgarciadelongoria/open-mova.git';
+const VERSION_PATTERN = /^v(\d+)\.(\d+)\.(\d+)$/;
+const EXCLUDED_ENTRIES = new Set([
+    '.git',
+    '.angular',
+    'node_modules',
+    'dist',
+    'out-tsc',
+    'android',
+    'ios',
+    'AGENTS.md',
+    'README.md',
+]);
+export function listShellVersions() {
+    const output = runGit(['ls-remote', '--tags', '--refs', SHELL_REPOSITORY]);
+    return output
+        .split('\n')
+        .map((line) => line.match(/refs\/tags\/(v\d+\.\d+\.\d+)$/)?.[1])
+        .filter((version) => version !== undefined)
+        .sort(compareVersionsDescending);
+}
+export function downloadShell(destination, requestedVersion) {
+    return downloadTaggedProject('open-mova-shell', destination, requestedVersion);
+}
+export function downloadTaggedProject(project, destination, requestedVersion) {
+    const versions = listShellVersions();
+    const version = requestedVersion ?? versions[0];
+    if (!version) {
+        throw new Error('El repositorio no tiene versiones estables con tags vX.Y.Z.');
+    }
+    if (!VERSION_PATTERN.test(version) || !versions.includes(version)) {
+        throw new Error(`La versión ${version} no está disponible. Usa "mova shell versions".`);
+    }
+    const temporaryDirectory = mkdtempSync(join(tmpdir(), 'open-mova-project-'));
+    try {
+        const checkout = join(temporaryDirectory, 'repository');
+        runGit([
+            '-c', 'advice.detachedHead=false',
+            'clone', '--quiet', '--depth', '1', '--single-branch',
+            '--branch', version, SHELL_REPOSITORY, checkout,
+        ]);
+        const source = join(checkout, project);
+        const requiredFiles = project === 'open-mova-core'
+            ? ['package.json', 'src/index.ts']
+            : ['package.json', 'angular.json', 'src/main.ts'];
+        for (const requiredFile of requiredFiles) {
+            if (!existsSync(join(source, requiredFile))) {
+                throw new Error(`El tag ${version} no contiene ${project}: falta ${requiredFile}.`);
+            }
+        }
+        cpSync(source, destination, {
+            recursive: true,
+            filter: (entry) => !EXCLUDED_ENTRIES.has(basename(entry)),
+        });
+        return {
+            repository: SHELL_REPOSITORY,
+            version,
+            commit: runGit(['-C', checkout, 'rev-parse', 'HEAD']).trim(),
+        };
+    }
+    finally {
+        rmSync(temporaryDirectory, { recursive: true, force: true });
+    }
+}
+export function configureDownloadedShell(destination, applicationName, includesStarterMicrofrontend) {
+    const packagePath = join(destination, 'package.json');
+    const packageLockPath = join(destination, 'package-lock.json');
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+    packageJson.name = applicationName;
+    packageJson.version = '0.1.0';
+    packageJson.private = true;
+    if (packageJson.dependencies?.['@open-mova/core']) {
+        packageJson.dependencies['@open-mova/core'] = 'file:packages/core';
+    }
+    writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`);
+    if (packageJson.dependencies?.['@open-mova/core']) {
+        // Las rutas file: cambian al copiar la shell fuera del monorepo.
+        rmSync(packageLockPath, { force: true });
+    }
+    else if (existsSync(packageLockPath)) {
+        const packageLock = JSON.parse(readFileSync(packageLockPath, 'utf8'));
+        packageLock.name = applicationName;
+        packageLock.version = packageJson.version;
+        packageLock.packages[''].name = applicationName;
+        packageLock.packages[''].version = packageJson.version;
+        writeFileSync(packageLockPath, `${JSON.stringify(packageLock, null, 2)}\n`);
+    }
+    const capacitorPath = join(destination, 'capacitor.config.ts');
+    if (existsSync(capacitorPath)) {
+        const originalConfig = readFileSync(capacitorPath, 'utf8');
+        const appId = `dev.openmova.app${applicationName.replaceAll('-', '')}`;
+        const customizedConfig = originalConfig
+            .replace(/(\bappId:\s*)['"][^'"]+['"]/, `$1'${appId}'`)
+            .replace(/(\bappName:\s*)['"][^'"]+['"]/, `$1'${applicationName}'`);
+        if (customizedConfig === originalConfig ||
+            !customizedConfig.includes(`appId: '${appId}'`) ||
+            !customizedConfig.includes(`appName: '${applicationName}'`)) {
+            throw new Error('No se pudo personalizar capacitor.config.ts de la shell descargada.');
+        }
+        writeFileSync(capacitorPath, customizedConfig);
+    }
+    writeFileSync(join(destination, '.nvmrc'), '22\n');
+    const usesCore = Boolean(packageJson.dependencies?.['@open-mova/core']);
+    const coreSteps = 'npm --prefix packages/core install\nnpm --prefix packages/core run build\n';
+    const librarySteps = usesCore || includesStarterMicrofrontend ? coreSteps : '';
+    const installSteps = `${librarySteps}npm install\n` +
+        (includesStarterMicrofrontend ? 'npm --prefix mfs/home install\n' : '');
+    const runSteps = includesStarterMicrofrontend
+        ? 'Inicia `npm --prefix mfs/home start` y `npm start` en dos terminales. Abre `http://localhost:4200/home/inicio`.\n'
+        : 'Registra primero un MF con `mova mf create nombre` y después ejecuta `mova start`.\n';
+    writeFileSync(join(destination, 'README.md'), `# ${applicationName}\n\nAplicación creada con Open Mova. \`mova.config.json\` registra la shell y los microfrontales remotos.\n\n` +
+        `Instala y compila las dependencias locales en este orden:\n\n` +
+        `\`\`\`bash\n${installSteps}\`\`\`\n\n${runSteps}`);
+}
+function compareVersionsDescending(first, second) {
+    const firstParts = VERSION_PATTERN.exec(first)?.slice(1).map(Number) ?? [];
+    const secondParts = VERSION_PATTERN.exec(second)?.slice(1).map(Number) ?? [];
+    for (let index = 0; index < 3; index += 1) {
+        const difference = (secondParts[index] ?? 0) - (firstParts[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return 0;
+}
+function runGit(args) {
+    const result = spawnSync('git', args, {
+        encoding: 'utf8',
+        timeout: 120_000,
+        maxBuffer: 10 * 1024 * 1024,
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    });
+    if (result.error || result.status !== 0) {
+        const detail = result.stderr?.trim() || result.error?.message || 'Error desconocido';
+        throw new Error(`No se pudo consultar o descargar Open Mova: ${detail}`);
+    }
+    return result.stdout;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { Command } from 'commander';
+import { registerBuildCommand } from './commands/build.js';
+import { registerCapacitorCommands } from './commands/capacitor.js';
+import { registerCreateCommand } from './commands/create.js';
+import { registerInfoCommand } from './commands/info.js';
+import { registerMicrofrontendCommands } from './commands/microfrontend.js';
+import { registerStartCommand } from './commands/start.js';
+import { registerShellCommands } from './commands/shell.js';
+const program = new Command();
+const packageVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+program
+    .name('mova')
+    .description('Herramientas de desarrollo para aplicaciones Open Mova')
+    .version(packageVersion.version);
+registerCreateCommand(program);
+registerMicrofrontendCommands(program);
+registerStartCommand(program);
+registerShellCommands(program);
+registerBuildCommand(program);
+registerCapacitorCommands(program);
+registerInfoCommand(program);
+try {
+    await program.parseAsync();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : 'Error inesperado.';
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+}

package/dist/commands/build.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerBuildCommand(program: Command): void;

package/dist/commands/build.js

@@ -0,0 +1,34 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { readApplicationConfiguration, requireApplicationRoot, } from '../application/configuration.js';
+export function registerBuildCommand(program) {
+    program
+        .command('build')
+        .description('Compila los microfrontales locales y después la shell')
+        .action(() => {
+        const applicationRoot = requireApplicationRoot(process.cwd());
+        const configuration = readApplicationConfiguration(applicationRoot);
+        for (const microfrontend of configuration.microfrontends) {
+            if (!microfrontend.sourcePath) {
+                continue;
+            }
+            const projectDirectory = resolve(applicationRoot, microfrontend.sourcePath);
+            if (!existsSync(projectDirectory)) {
+                throw new Error(`No se encuentra el microfrontal "${microfrontend.name}" en ${projectDirectory}.`);
+            }
+            runBuild(projectDirectory, `microfrontal ${microfrontend.name}`);
+        }
+        runBuild(applicationRoot, 'shell');
+    });
+}
+function runBuild(directory, label) {
+    console.log(`Compilando ${label}...`);
+    const result = spawnSync('npm', ['run', 'build'], {
+        cwd: directory,
+        stdio: 'inherit',
+    });
+    if (result.status !== 0) {
+        throw new Error(`La compilación de ${label} no ha finalizado correctamente.`);
+    }
+}

package/dist/commands/capacitor.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCapacitorCommands(program: Command): void;

package/dist/commands/capacitor.js

@@ -0,0 +1,84 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readApplicationConfiguration, requireApplicationRoot, } from '../application/configuration.js';
+export function registerCapacitorCommands(program) {
+    const capacitor = program.command('cap').description('Prepara la shell para Android o iOS');
+    capacitor.command('add <platform>')
+        .description('Crea el proyecto nativo de la plataforma')
+        .action((platform) => {
+        const selectedPlatform = parsePlatform(platform);
+        const root = requireApplicationRoot(process.cwd());
+        buildMobileShell(root);
+        runCapacitor(root, ['add', selectedPlatform]);
+    });
+    capacitor.command('sync [platform]')
+        .description('Compila la shell y sincroniza sus assets y plugins nativos')
+        .action((platform) => {
+        const root = requireApplicationRoot(process.cwd());
+        buildMobileShell(root);
+        runCapacitor(root, ['sync', ...(platform ? [parsePlatform(platform)] : [])]);
+    });
+    capacitor.command('open <platform>')
+        .description('Abre el proyecto nativo en Android Studio o Xcode')
+        .action((platform) => {
+        const root = requireApplicationRoot(process.cwd());
+        runCapacitor(root, ['open', parsePlatform(platform)]);
+    });
+}
+function parsePlatform(value) {
+    if (value !== 'android' && value !== 'ios') {
+        throw new Error('La plataforma debe ser android o ios.');
+    }
+    return value;
+}
+function buildMobileShell(root) {
+    if (!existsSync(join(root, 'capacitor.config.ts'))) {
+        throw new Error('Esta versión de shell no incluye Capacitor. Usa una shell v0.1.2 o posterior.');
+    }
+    const configuration = readApplicationConfiguration(root);
+    const manifest = createProductionManifest(configuration);
+    run(root, 'npm', ['run', 'build']);
+    const webDirectory = join(root, 'dist', 'browser');
+    if (!existsSync(join(webDirectory, 'index.html'))) {
+        throw new Error(`No se encuentra la shell compilada en ${webDirectory}.`);
+    }
+    // La compilación usa URLs locales para desarrollo; solo el artefacto móvil usa HTTPS.
+    writeFileSync(join(webDirectory, 'assets', 'federation.manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}
+function createProductionManifest(configuration) {
+    return Object.fromEntries(configuration.microfrontends.map((microfrontend) => {
+        const entry = microfrontend.productionRemoteEntry;
+        if (!entry || !isHttpsUrl(entry)) {
+            throw new Error(`Configura productionRemoteEntry con HTTPS para el microfrontal "${microfrontend.name}" en mova.config.json.`);
+        }
+        return [microfrontend.remoteName, entry];
+    }));
+}
+function isHttpsUrl(value) {
+    try {
+        return new URL(value).protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function runCapacitor(root, args) {
+    if (!existsSync(join(root, 'capacitor.config.ts'))) {
+        throw new Error('Esta versión de shell no incluye Capacitor. Usa una shell v0.1.2 o posterior.');
+    }
+    const binary = join(root, 'node_modules', '.bin', 'cap');
+    if (!existsSync(binary)) {
+        throw new Error('Instala las dependencias de la aplicación con npm install.');
+    }
+    run(root, binary, args);
+}
+function run(root, command, args) {
+    const result = spawnSync(command, args, { cwd: root, stdio: 'inherit' });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(`${command} ${args.join(' ')} terminó con error.`);
+    }
+}

package/dist/commands/create.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCreateCommand(program: Command): void;

package/dist/commands/create.js

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { createMicrofrontend } from '../application/microfrontend.js';
+import { addMicrofrontend, writeApplicationConfiguration, } from '../application/configuration.js';
+import { synchronizeShellConfiguration } from '../application/shell-configuration.js';
+import { configureDownloadedShell, downloadShell, downloadTaggedProject, } from '../application/shell-repository.js';
+import { normalizeName } from '../utils/names.js';
+export function registerCreateCommand(program) {
+    program
+        .command('create <name>')
+        .description('Crea una aplicación Open Mova con una shell y un microfrontal inicial')
+        .option('-d, --directory <path>', 'directorio donde crear la aplicación')
+        .option('--empty', 'no crear el microfrontal inicial')
+        .option('--shell-version <tag>', 'tag de la shell, por ejemplo v0.1.4')
+        .action((name, options) => {
+        const applicationName = normalizeName(name, 'El nombre de la aplicación');
+        const applicationRoot = resolve(options.directory ?? join(process.cwd(), applicationName));
+        if (existsSync(applicationRoot)) {
+            throw new Error(`Ya existe un directorio en ${applicationRoot}.`);
+        }
+        mkdirSync(dirname(applicationRoot), { recursive: true });
+        const temporaryApplication = mkdtempSync(join(dirname(applicationRoot), '.mova-create-'));
+        let shellVersion;
+        try {
+            const shell = downloadShell(temporaryApplication, options.shellVersion);
+            shellVersion = shell.version;
+            const shellPackage = JSON.parse(readFileSync(join(temporaryApplication, 'package.json'), 'utf8'));
+            const shellUsesCore = Boolean(shellPackage.dependencies?.['@open-mova/core']);
+            if (shellUsesCore || !options.empty) {
+                downloadTaggedProject('open-mova-core', join(temporaryApplication, 'packages/core'), shell.version);
+            }
+            configureDownloadedShell(temporaryApplication, applicationName, !options.empty);
+            let configuration = {
+                schemaVersion: 1,
+                name: applicationName,
+                shell,
+                microfrontends: [],
+            };
+            if (!options.empty) {
+                const starterMicrofrontend = createMicrofrontend(temporaryApplication, configuration, {
+                    name: 'home',
+                    directory: join('mfs', 'home'),
+                    profile: 'demo',
+                    templateVersion: shell.version,
+                });
+                configuration = addMicrofrontend(configuration, starterMicrofrontend);
+            }
+            writeApplicationConfiguration(temporaryApplication, configuration);
+            synchronizeShellConfiguration(temporaryApplication, configuration);
+            if (existsSync(applicationRoot)) {
+                throw new Error(`Ya existe un directorio en ${applicationRoot}.`);
+            }
+            renameSync(temporaryApplication, applicationRoot);
+        }
+        finally {
+            rmSync(temporaryApplication, { recursive: true, force: true });
+        }
+        console.log(`Aplicación creada en ${applicationRoot} con shell ${shellVersion}.`);
+        console.log('Instala las dependencias antes de iniciar el desarrollo:');
+        console.log(`  cd ${applicationRoot}`);
+        const createdWithCore = existsSync(join(applicationRoot, 'packages/core'));
+        if (createdWithCore) {
+            console.log('  npm --prefix packages/core install && npm --prefix packages/core run build');
+        }
+        console.log('  npm install');
+        if (!options.empty) {
+            console.log('  npm --prefix mfs/home install');
+        }
+    });
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerInfoCommand(program: Command): void;

package/dist/commands/info.js

@@ -0,0 +1,26 @@
+import { resolve } from 'node:path';
+import { findApplicationRoot, readApplicationConfiguration, } from '../application/configuration.js';
+export function registerInfoCommand(program) {
+    program
+        .command('info')
+        .description('Muestra la aplicación Open Mova encontrada desde la carpeta actual')
+        .action(() => {
+        const currentDirectory = resolve(process.cwd());
+        const applicationRoot = findApplicationRoot(currentDirectory);
+        console.log(`Directorio actual: ${currentDirectory}`);
+        if (!applicationRoot) {
+            console.log('Aplicación Open Mova: no encontrada');
+            return;
+        }
+        const configuration = readApplicationConfiguration(applicationRoot);
+        console.log(`Aplicación Open Mova: ${configuration.name}`);
+        console.log(`Raíz de la aplicación: ${applicationRoot}`);
+        if (configuration.shell) {
+            console.log(`Shell: ${configuration.shell.version} (${configuration.shell.commit.slice(0, 7)})`);
+        }
+        console.log(`Microfrontales registrados: ${configuration.microfrontends.length}`);
+        for (const microfrontend of configuration.microfrontends) {
+            console.log(`- ${microfrontend.name} → /${microfrontend.route}`);
+        }
+    });
+}

package/dist/commands/microfrontend.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerMicrofrontendCommands(program: Command): void;

package/dist/commands/microfrontend.js

@@ -0,0 +1,85 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createMicrofrontend, inspectExistingMicrofrontend } from '../application/microfrontend.js';
+import { addMicrofrontend, readApplicationConfiguration, requireApplicationRoot, writeApplicationConfiguration, } from '../application/configuration.js';
+import { synchronizeShellConfiguration } from '../application/shell-configuration.js';
+import { normalizeName } from '../utils/names.js';
+import { downloadTaggedProject, listShellVersions } from '../application/shell-repository.js';
+export function registerMicrofrontendCommands(program) {
+    const microfrontend = program
+        .command('mf')
+        .description('Crea y registra microfrontales de una aplicación Open Mova');
+    microfrontend
+        .command('create <name>')
+        .description('Crea un microfrontal local y lo registra en la aplicación')
+        .option('-d, --directory <path>', 'ruta relativa a la raíz de la aplicación')
+        .option('--route <path>', 'ruta pública en la shell')
+        .option('--port <number>', 'puerto de desarrollo', parsePort)
+        .option('--production-remote-entry <url>', 'URL HTTPS del remoto publicado')
+        .option('--template-version <tag>', 'tag del proyecto de microfrontal')
+        .option('--demo', 'usar el perfil con ejemplos en vez del mínimo')
+        .action((name, options) => {
+        const applicationRoot = requireApplicationRoot(process.cwd());
+        const configuration = readApplicationConfiguration(applicationRoot);
+        const normalizedName = normalizeName(name, 'El nombre del microfrontal');
+        const templateVersion = options.templateVersion ?? (options.demo ? configuration.shell?.version : undefined) ?? listShellVersions()[0];
+        if (!templateVersion) {
+            throw new Error('No hay tags estables disponibles para crear el microfrontal.');
+        }
+        if (options.demo && configuration.shell?.version !== templateVersion) {
+            throw new Error('El perfil demo debe usar el mismo tag que la shell para mantener compatible el contrato nativo.');
+        }
+        if (options.demo && !existsSync(join(applicationRoot, 'packages/core'))) {
+            downloadTaggedProject('open-mova-core', join(applicationRoot, 'packages/core'), templateVersion);
+        }
+        const microfrontendConfiguration = createMicrofrontend(applicationRoot, configuration, {
+            name: normalizedName,
+            directory: options.directory ?? join('mfs', normalizedName),
+            route: options.route,
+            port: options.port,
+            productionRemoteEntry: options.productionRemoteEntry,
+            templateVersion,
+            profile: options.demo ? 'demo' : 'minimal',
+        });
+        const updatedConfiguration = addMicrofrontend(configuration, microfrontendConfiguration);
+        writeApplicationConfiguration(applicationRoot, updatedConfiguration);
+        synchronizeShellConfiguration(applicationRoot, updatedConfiguration);
+        console.log(`Microfrontal "${microfrontendConfiguration.name}" creado.`);
+        console.log(`Ruta pública: /${microfrontendConfiguration.route}`);
+        console.log(`Directorio: ${microfrontendConfiguration.sourcePath}`);
+    });
+    microfrontend
+        .command('add [source-path]')
+        .description('Registra un microfrontal local o uno ya desplegado')
+        .option('--name <name>', 'nombre del microfrontal')
+        .option('--route <path>', 'ruta pública en la shell')
+        .option('--remote <name>', 'nombre definido en federation.config.js')
+        .option('--remote-entry <url>', 'URL del remoteEntry.json')
+        .option('--port <number>', 'puerto de desarrollo para un proyecto local', parsePort)
+        .option('--production-remote-entry <url>', 'URL HTTPS del remoto publicado')
+        .action((sourcePath, options) => {
+        const applicationRoot = requireApplicationRoot(process.cwd());
+        const configuration = readApplicationConfiguration(applicationRoot);
+        const microfrontendConfiguration = inspectExistingMicrofrontend(applicationRoot, {
+            sourcePath,
+            name: options.name,
+            route: options.route,
+            remoteName: options.remote,
+            remoteEntry: options.remoteEntry,
+            port: options.port,
+            productionRemoteEntry: options.productionRemoteEntry,
+        });
+        const updatedConfiguration = addMicrofrontend(configuration, microfrontendConfiguration);
+        writeApplicationConfiguration(applicationRoot, updatedConfiguration);
+        synchronizeShellConfiguration(applicationRoot, updatedConfiguration);
+        console.log(`Microfrontal "${microfrontendConfiguration.name}" registrado.`);
+        console.log(`Ruta pública: /${microfrontendConfiguration.route}`);
+    });
+}
+function parsePort(value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error('El puerto debe ser un número entero entre 1 y 65535.');
+    }
+    return port;
+}

package/dist/commands/shell.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerShellCommands(program: Command): void;

package/dist/commands/shell.js

@@ -0,0 +1,18 @@
+import { listShellVersions } from '../application/shell-repository.js';
+export function registerShellCommands(program) {
+    program
+        .command('shell')
+        .description('Consulta las versiones publicadas de la shell')
+        .command('versions')
+        .description('Muestra los tags estables disponibles en el repositorio')
+        .action(() => {
+        const versions = listShellVersions();
+        if (versions.length === 0) {
+            console.log('No hay versiones estables disponibles.');
+            return;
+        }
+        for (const [index, version] of versions.entries()) {
+            console.log(index === 0 ? `${version} (última)` : version);
+        }
+    });
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerStartCommand(program: Command): void;

package/dist/commands/start.js

@@ -0,0 +1,69 @@
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { readApplicationConfiguration, requireApplicationRoot, } from '../application/configuration.js';
+export function registerStartCommand(program) {
+    program
+        .command('start')
+        .description('Inicia la shell y los microfrontales locales registrados')
+        .option('--shell-only', 'inicia solo la shell')
+        .action(async (options) => {
+        const applicationRoot = requireApplicationRoot(process.cwd());
+        const configuration = readApplicationConfiguration(applicationRoot);
+        const projects = [];
+        if (!options.shellOnly) {
+            for (const microfrontend of configuration.microfrontends) {
+                if (!microfrontend.sourcePath) {
+                    continue;
+                }
+                const projectDirectory = resolve(applicationRoot, microfrontend.sourcePath);
+                if (!existsSync(projectDirectory)) {
+                    throw new Error(`No se encuentra el microfrontal "${microfrontend.name}" en ${projectDirectory}.`);
+                }
+                projects.push({
+                    directory: projectDirectory,
+                    label: `MF ${microfrontend.name}`,
+                });
+            }
+        }
+        projects.push({ directory: applicationRoot, label: 'Shell' });
+        console.log('Iniciando proyectos. Pulsa Ctrl+C para detenerlos.');
+        await startProjects(projects);
+    });
+}
+async function startProjects(projects) {
+    const children = projects.map(({ directory, label }) => {
+        console.log(`- ${label}: ${directory}`);
+        return spawn('npm', ['run', 'start'], {
+            cwd: directory,
+            stdio: 'inherit',
+        });
+    });
+    const stopChildren = () => {
+        for (const child of children) {
+            child.kill('SIGTERM');
+        }
+    };
+    const stopOnSignal = () => {
+        stopChildren();
+    };
+    process.once('SIGINT', stopOnSignal);
+    process.once('SIGTERM', stopOnSignal);
+    try {
+        const result = await Promise.race(children.map(waitForExit));
+        if (result.code !== 0 && result.signal === null) {
+            throw new Error('Uno de los servidores de desarrollo ha terminado con error.');
+        }
+    }
+    finally {
+        process.removeListener('SIGINT', stopOnSignal);
+        process.removeListener('SIGTERM', stopOnSignal);
+        stopChildren();
+    }
+}
+function waitForExit(child) {
+    return new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('exit', (code, signal) => resolve({ code, signal }));
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export interface OpenMovaApplicationConfiguration {
+    readonly schemaVersion: 1;
+    readonly name: string;
+    readonly shell?: {
+        readonly repository: string;
+        readonly version: string;
+        readonly commit: string;
+    };
+    readonly microfrontends: readonly MicrofrontendConfiguration[];
+}
+export interface MicrofrontendConfiguration {
+    readonly name: string;
+    readonly route: string;
+    readonly remoteName: string;
+    readonly exposedModule: './Routes';
+    readonly developmentRemoteEntry: string;
+    readonly productionRemoteEntry?: string;
+    readonly sourcePath?: string;
+    readonly template?: {
+        readonly repository: string;
+        readonly version: string;
+        readonly commit: string;
+        readonly project: 'open-mova-mf-template';
+        readonly profile: 'minimal' | 'demo';
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/names.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeName(value: string, label: string): string;
+export declare function toDisplayName(value: string): string;
+export declare function toPascalCase(value: string): string;
+export declare function toRemoteName(name: string): string;