@open-mova/cli 0.1.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Open Mova contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,172 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/rgarciadelongoria/open-mova/main/assets/brand/open-mova-logo-title-rectangle.png" alt="Open Mova" width="720">
+</p>
+
+# Open Mova CLI
+
+CLI de terminal para crear y mantener aplicaciones Open Mova. Se ejecuta desde la raíz de cada aplicación con el comando `mova`.
+
+El CLI descarga la shell, el core y la plantilla de microfrontales desde tags estables del repositorio de Open Mova. No contiene copias de esas plantillas. Cada aplicación guarda en `mova.config.json` el tag y el commit con los que fue creada.
+
+## Índice de comandos
+
+- [`mova create`](#mova-create)
+- [`mova mf create`](#mova-mf-create)
+- [`mova mf add`](#mova-mf-add)
+- [`mova start`](#mova-start)
+- [`mova build`](#mova-build)
+- [`mova info`](#mova-info)
+- [`mova shell versions`](#mova-shell-versions)
+- [`mova cap add`](#mova-cap-add)
+- [`mova cap sync`](#mova-cap-sync)
+- [`mova cap open`](#mova-cap-open)
+
+## Instalación
+
+Requiere Node.js 22 o posterior.
+
+```bash
+npm install --global @open-mova/cli
+mova --help
+```
+
+## Instalación para desarrollar el CLI
+
+Requiere Node.js 22.
+
+```bash
+cd open-mova-cli
+npm install
+npm run typecheck
+npm run build
+npm link
+```
+
+`npm link` enlaza la versión local del comando `mova`; no publica el paquete.
+
+## Comandos
+
+### `mova create`
+
+Crea una aplicación completa. Descarga una shell versionada, el core y un MF inicial `home`.
+
+```bash
+mova create mi-aplicacion
+mova create mi-aplicacion --directory ../apps/mi-aplicacion
+mova create mi-aplicacion --shell-version v0.1.9
+mova create mi-aplicacion --empty
+```
+
+Sin `--shell-version` se usa el tag estable más reciente (`vMAJOR.MINOR.PATCH`). `--empty` omite el MF inicial.
+
+### `mova mf create`
+
+Crea un microfrontal local, lo registra y actualiza la configuración de federación de la shell.
+
+```bash
+cd mi-aplicacion
+mova mf create catalog
+mova mf create catalog --route productos --port 4500
+mova mf create catalog --directory ../provider-mf-catalog
+mova mf create catalog --demo
+```
+
+Por defecto se crea en `mfs/catalog`, con perfil mínimo, ruta `/catalog` y un puerto libre desde `4300`. `--demo` añade ejemplos de Device y Camera. Se puede fijar la plantilla con `--template-version v0.1.9`.
+
+### `mova mf add`
+
+Registra un microfrontal existente, sin crearlo de nuevo.
+
+```bash
+mova mf add ../provider-mf-catalog
+mova mf add ../provider-mf-catalog --name catalog --route productos \
+  --remote catalog-microfrontend --port 4500
+```
+
+Para registrar solo un MF ya publicado:
+
+```bash
+mova mf add --name catalog --route productos \
+  --remote catalog-microfrontend \
+  --remote-entry https://cdn.example.com/catalog/remoteEntry.json
+```
+
+El CLI actualiza `mova.config.json`, `src/assets/federation.manifest.json` y `src/app/application.config.ts`.
+
+### `mova start`
+
+Arranca los MFs locales registrados y después la shell. Los MFs configurados solo con una URL remota no se arrancan localmente.
+
+```bash
+mova start
+mova start --shell-only
+```
+
+### `mova build`
+
+Compila los microfrontales locales y la shell.
+
+```bash
+mova build
+```
+
+### `mova info`
+
+Muestra la aplicación detectada, la versión de shell y sus microfrontales. También funciona desde subdirectorios como `mfs/catalog`.
+
+```bash
+mova info
+```
+
+### `mova shell versions`
+
+Lista los tags estables disponibles para crear aplicaciones.
+
+```bash
+mova shell versions
+```
+
+### `mova cap add`
+
+Compila la aplicación y añade una plataforma nativa. Configura antes el `appId` definitivo en `capacitor.config.ts`.
+
+```bash
+mova cap add android
+mova cap add ios
+```
+
+### `mova cap sync`
+
+Sincroniza la shell compilada, los recursos y los plugins con la plataforma. Sin plataforma, sincroniza todas las plataformas añadidas.
+
+```bash
+mova cap sync android
+mova cap sync
+```
+
+### `mova cap open`
+
+Abre el proyecto nativo en Android Studio o Xcode.
+
+```bash
+mova cap open android
+mova cap open ios
+```
+
+## Flujo habitual
+
+```bash
+mova create mi-aplicacion
+cd mi-aplicacion
+npm install
+npm --prefix packages/core install
+npm --prefix packages/core run build
+npm --prefix mfs/home install
+mova start
+```
+
+Los microfrontales siempre se cargan remotamente mediante Native Federation. En producción, cada MF debe estar publicado en HTTPS y registrado con su `productionRemoteEntry`. Capacitor no copia los MFs al paquete nativo: la shell los carga desde sus URLs en ejecución.
+
+## Limitaciones actuales
+
+El CLI todavía no actualiza automáticamente la shell de una aplicación creada ni publica microfrontales. Los comandos móviles requieren una versión de shell que incluya Capacitor.

package/dist/application/configuration.d.ts

@@ -0,0 +1,7 @@
+import type { MicrofrontendConfiguration, OpenMovaApplicationConfiguration } from '../types.js';
+export declare const APPLICATION_CONFIGURATION_FILE = "mova.config.json";
+export declare function findApplicationRoot(startDirectory: string): string | undefined;
+export declare function requireApplicationRoot(startDirectory: string): string;
+export declare function readApplicationConfiguration(applicationRoot: string): OpenMovaApplicationConfiguration;
+export declare function writeApplicationConfiguration(applicationRoot: string, configuration: OpenMovaApplicationConfiguration): void;
+export declare function addMicrofrontend(configuration: OpenMovaApplicationConfiguration, microfrontend: MicrofrontendConfiguration): OpenMovaApplicationConfiguration;

package/dist/application/configuration.js

@@ -0,0 +1,135 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+export const APPLICATION_CONFIGURATION_FILE = 'mova.config.json';
+export function findApplicationRoot(startDirectory) {
+    let currentDirectory = resolve(startDirectory);
+    while (true) {
+        if (existsSync(join(currentDirectory, APPLICATION_CONFIGURATION_FILE))) {
+            return currentDirectory;
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return undefined;
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+export function requireApplicationRoot(startDirectory) {
+    const applicationRoot = findApplicationRoot(startDirectory);
+    if (!applicationRoot) {
+        throw new Error(`No se ha encontrado ${APPLICATION_CONFIGURATION_FILE}. Ejecuta este comando desde una aplicación Open Mova.`);
+    }
+    return applicationRoot;
+}
+export function readApplicationConfiguration(applicationRoot) {
+    const configurationPath = join(applicationRoot, APPLICATION_CONFIGURATION_FILE);
+    try {
+        const parsed = JSON.parse(readFileSync(configurationPath, 'utf8'));
+        return validateApplicationConfiguration(parsed, configurationPath);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error(`No se ha podido leer ${configurationPath}.`);
+    }
+}
+export function writeApplicationConfiguration(applicationRoot, configuration) {
+    const configurationPath = join(applicationRoot, APPLICATION_CONFIGURATION_FILE);
+    const content = `${JSON.stringify(configuration, null, 2)}\n`;
+    writeFileSync(configurationPath, content, 'utf8');
+}
+export function addMicrofrontend(configuration, microfrontend) {
+    const routeInUse = configuration.microfrontends.some((entry) => entry.route === microfrontend.route);
+    const nameInUse = configuration.microfrontends.some((entry) => entry.name === microfrontend.name);
+    const remoteInUse = configuration.microfrontends.some((entry) => entry.remoteName === microfrontend.remoteName);
+    const remoteEntryInUse = configuration.microfrontends.some((entry) => entry.developmentRemoteEntry === microfrontend.developmentRemoteEntry);
+    if (nameInUse || routeInUse || remoteInUse || remoteEntryInUse) {
+        throw new Error(`El microfrontal "${microfrontend.name}" entra en conflicto con una entrada existente. ` +
+            'El nombre, la ruta, el remoto y la URL de desarrollo deben ser únicos.');
+    }
+    return {
+        ...configuration,
+        microfrontends: [...configuration.microfrontends, microfrontend],
+    };
+}
+function validateApplicationConfiguration(value, configurationPath) {
+    if (!isRecord(value)) {
+        throw new Error(`${configurationPath} no contiene un objeto JSON válido.`);
+    }
+    if (value.schemaVersion !== 1 || typeof value.name !== 'string') {
+        throw new Error(`${configurationPath} no tiene el formato de Open Mova esperado.`);
+    }
+    if (!Array.isArray(value.microfrontends)) {
+        throw new Error(`${configurationPath} debe contener una lista de microfrontales.`);
+    }
+    let shell;
+    if (value.shell !== undefined) {
+        if (!isRecord(value.shell) ||
+            typeof value.shell.repository !== 'string' ||
+            typeof value.shell.version !== 'string' ||
+            typeof value.shell.commit !== 'string') {
+            throw new Error(`${configurationPath} contiene una versión de shell no válida.`);
+        }
+        shell = {
+            repository: value.shell.repository,
+            version: value.shell.version,
+            commit: value.shell.commit,
+        };
+    }
+    const microfrontends = value.microfrontends.map((entry) => validateMicrofrontend(entry, configurationPath));
+    return {
+        schemaVersion: 1,
+        name: value.name,
+        ...(shell ? { shell } : {}),
+        microfrontends,
+    };
+}
+function validateMicrofrontend(value, configurationPath) {
+    if (!isRecord(value)) {
+        throw new Error(`${configurationPath} contiene un microfrontal no válido.`);
+    }
+    const requiredStrings = [
+        value.name,
+        value.route,
+        value.remoteName,
+        value.exposedModule,
+        value.developmentRemoteEntry,
+    ];
+    if (requiredStrings.some((entry) => typeof entry !== 'string')) {
+        throw new Error(`${configurationPath} contiene un microfrontal incompleto.`);
+    }
+    if (value.exposedModule !== './Routes') {
+        throw new Error(`${configurationPath} solo admite "./Routes" como módulo expuesto por el momento.`);
+    }
+    if (value.sourcePath !== undefined && typeof value.sourcePath !== 'string') {
+        throw new Error(`${configurationPath} contiene una ruta de origen no válida.`);
+    }
+    if (value.productionRemoteEntry !== undefined &&
+        typeof value.productionRemoteEntry !== 'string') {
+        throw new Error(`${configurationPath} contiene una URL de producción no válida.`);
+    }
+    if (value.template !== undefined && (!isRecord(value.template) ||
+        typeof value.template.repository !== 'string' ||
+        typeof value.template.version !== 'string' ||
+        typeof value.template.commit !== 'string' ||
+        value.template.project !== 'open-mova-mf-template' ||
+        (value.template.profile !== 'minimal' && value.template.profile !== 'demo'))) {
+        throw new Error(`${configurationPath} contiene una plantilla de microfrontal no válida.`);
+    }
+    return {
+        name: value.name,
+        route: value.route,
+        remoteName: value.remoteName,
+        exposedModule: './Routes',
+        developmentRemoteEntry: value.developmentRemoteEntry,
+        ...(value.productionRemoteEntry === undefined
+            ? {}
+            : { productionRemoteEntry: value.productionRemoteEntry }),
+        ...(value.sourcePath === undefined ? {} : { sourcePath: value.sourcePath }),
+        ...(value.template === undefined ? {} : { template: value.template }),
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/application/microfrontend-profile.d.ts

@@ -0,0 +1,2 @@
+export type MicrofrontendProfile = 'minimal' | 'demo';
+export declare function configureDownloadedMicrofrontend(destination: string, applicationRoot: string, name: string, port: number, profile: MicrofrontendProfile): void;

package/dist/application/microfrontend-profile.js

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { toDisplayName, toRemoteName } from '../utils/names.js';
+export function configureDownloadedMicrofrontend(destination, applicationRoot, name, port, profile) {
+    const projectName = `mova-mf-${name}`;
+    const packagePath = join(destination, 'package.json');
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+    packageJson.name = projectName;
+    packageJson.scripts.start = `ng serve ${projectName}`;
+    packageJson.scripts.build = `ng build ${projectName}`;
+    if (profile === 'minimal') {
+        delete packageJson.dependencies['@open-mova/core'];
+        writeFileSync(join(destination, 'src/app/app.routes.ts'), minimalRoutes(name));
+        writeFileSync(join(destination, 'src/app/app.config.ts'), minimalAppConfig());
+    }
+    else {
+        const core = join(applicationRoot, 'packages/core');
+        if (!existsSync(core)) {
+            throw new Error('El perfil demo requiere packages/core en la aplicación.');
+        }
+        packageJson.dependencies['@open-mova/core'] = `file:${relative(destination, core)}`;
+    }
+    writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`);
+    const angularPath = join(destination, 'angular.json');
+    const angular = readFileSync(angularPath, 'utf8')
+        .replaceAll('open-mova-mf-template', projectName)
+        .replace('"port": 4300', `"port": ${port}`);
+    writeFileSync(angularPath, angular);
+    const federationPath = join(destination, 'federation.config.js');
+    writeFileSync(federationPath, readFileSync(federationPath, 'utf8').replace('demo-microfrontend', toRemoteName(name)));
+    const indexPath = join(destination, 'src/index.html');
+    writeFileSync(indexPath, readFileSync(indexPath, 'utf8')
+        .replaceAll('Demo microfrontend', toDisplayName(name))
+        .replaceAll('mova-demo-microfrontend', `mova-${name}-microfrontend`));
+    const appPath = join(destination, 'src/app/app.ts');
+    writeFileSync(appPath, readFileSync(appPath, 'utf8').replace('mova-demo-microfrontend', `mova-${name}-microfrontend`));
+    // El lock heredado ya no representa el proyecto renombrado ni su dependencia local.
+    rmSync(join(destination, 'package-lock.json'), { force: true });
+    writeFileSync(join(destination, 'README.md'), `# ${projectName}\n\nMicrofrontal Open Mova (${profile}). Ejecuta \`npm install\` y \`npm start\`. La shell lo carga en http://localhost:${port}/remoteEntry.json.\n`);
+}
+function minimalRoutes(name) {
+    return `import { Component } from '@angular/core';
+import { Routes } from '@angular/router';
+
+@Component({
+  standalone: true,
+  template: '<h1>${toDisplayName(name)}</h1>',
+})
+export class HomeComponent {}
+
+// Añade aquí las rutas y componentes propios de este microfrontal.
+export const routes: Routes = [
+  { path: '', component: HomeComponent },
+];
+`;
+}
+function minimalAppConfig() {
+    return `import { ApplicationConfig } from '@angular/core';
+import { provideRouter } from '@angular/router';
+import { routes } from './app.routes';
+
+export const appConfig: ApplicationConfig = {
+  providers: [provideRouter(routes)],
+};
+`;
+}

package/dist/application/microfrontend.d.ts

@@ -0,0 +1,22 @@
+import type { MicrofrontendConfiguration, OpenMovaApplicationConfiguration } from '../types.js';
+import { type MicrofrontendProfile } from './microfrontend-profile.js';
+export interface CreateMicrofrontendOptions {
+    readonly name: string;
+    readonly directory: string;
+    readonly route?: string;
+    readonly port?: number;
+    readonly productionRemoteEntry?: string;
+    readonly profile?: MicrofrontendProfile;
+    readonly templateVersion?: string;
+}
+export interface ExistingMicrofrontendOptions {
+    readonly sourcePath?: string;
+    readonly name?: string;
+    readonly route?: string;
+    readonly remoteName?: string;
+    readonly remoteEntry?: string;
+    readonly productionRemoteEntry?: string;
+    readonly port?: number;
+}
+export declare function createMicrofrontend(applicationRoot: string, configuration: OpenMovaApplicationConfiguration, options: CreateMicrofrontendOptions): MicrofrontendConfiguration;
+export declare function inspectExistingMicrofrontend(applicationRoot: string, options: ExistingMicrofrontendOptions): MicrofrontendConfiguration;

package/dist/application/microfrontend.js

@@ -0,0 +1,135 @@
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { relative, resolve, sep } from 'node:path';
+import { normalizeName, toRemoteName } from '../utils/names.js';
+import { configureDownloadedMicrofrontend } from './microfrontend-profile.js';
+import { downloadTaggedProject } from './shell-repository.js';
+export function createMicrofrontend(applicationRoot, configuration, options) {
+    const name = normalizeName(options.name, 'El nombre del microfrontal');
+    const route = normalizeName(options.route ?? name, 'La ruta del microfrontal');
+    const destination = resolve(applicationRoot, options.directory);
+    if (existsSync(destination)) {
+        throw new Error(`Ya existe un directorio en ${destination}.`);
+    }
+    const port = options.port ?? findAvailablePort(configuration);
+    validatePort(port);
+    const profile = options.profile ?? 'minimal';
+    let template;
+    try {
+        template = downloadTaggedProject('open-mova-mf-template', destination, options.templateVersion);
+        configureDownloadedMicrofrontend(destination, applicationRoot, name, port, profile);
+    }
+    catch (error) {
+        rmSync(destination, { recursive: true, force: true });
+        throw error;
+    }
+    return {
+        name,
+        route,
+        remoteName: toRemoteName(name),
+        exposedModule: './Routes',
+        developmentRemoteEntry: `http://localhost:${port}/remoteEntry.json`,
+        ...(options.productionRemoteEntry
+            ? { productionRemoteEntry: options.productionRemoteEntry }
+            : {}),
+        sourcePath: toConfigurationPath(applicationRoot, destination),
+        template: { ...template, project: 'open-mova-mf-template', profile },
+    };
+}
+export function inspectExistingMicrofrontend(applicationRoot, options) {
+    if (!options.sourcePath && !options.remoteEntry) {
+        throw new Error('Indica una ruta de proyecto o usa --remote-entry para registrar un microfrontal ya desplegado.');
+    }
+    const sourceDirectory = options.sourcePath
+        ? resolve(applicationRoot, options.sourcePath)
+        : undefined;
+    const discovered = sourceDirectory
+        ? inspectLocalProject(sourceDirectory)
+        : { remoteName: undefined, port: undefined };
+    const remoteName = options.remoteName ?? discovered.remoteName;
+    const inferredName = remoteName?.replace(/-microfrontend$/, '');
+    const name = normalizeName(options.name ?? inferredName ?? '', 'El nombre del microfrontal');
+    const route = normalizeName(options.route ?? name, 'La ruta del microfrontal');
+    const resolvedRemoteName = remoteName ?? toRemoteName(name);
+    const port = options.port ?? discovered.port;
+    if (port !== undefined) {
+        validatePort(port);
+    }
+    const remoteEntry = options.remoteEntry ??
+        (port === undefined ? undefined : `http://localhost:${port}/remoteEntry.json`);
+    if (!remoteEntry) {
+        throw new Error('No se ha podido detectar el puerto. Indica --remote-entry o --port.');
+    }
+    return {
+        name,
+        route,
+        remoteName: resolvedRemoteName,
+        exposedModule: './Routes',
+        developmentRemoteEntry: remoteEntry,
+        ...(options.productionRemoteEntry
+            ? { productionRemoteEntry: options.productionRemoteEntry }
+            : {}),
+        ...(sourceDirectory
+            ? { sourcePath: toConfigurationPath(applicationRoot, sourceDirectory) }
+            : {}),
+    };
+}
+function inspectLocalProject(directory) {
+    const federationConfiguration = resolve(directory, 'federation.config.js');
+    const angularConfiguration = resolve(directory, 'angular.json');
+    const packageConfiguration = resolve(directory, 'package.json');
+    if (!existsSync(federationConfiguration) ||
+        !existsSync(angularConfiguration) ||
+        !existsSync(packageConfiguration)) {
+        throw new Error(`${directory} no parece un microfrontal Open Mova. Debe contener package.json, angular.json y federation.config.js.`);
+    }
+    const federationContent = readFileSync(federationConfiguration, 'utf8');
+    const remoteName = federationContent.match(/\bname\s*:\s*['"]([^'"]+)['"]/)?.[1];
+    const port = readPort(angularConfiguration);
+    return { remoteName, port };
+}
+function readPort(configurationPath) {
+    const parsed = JSON.parse(readFileSync(configurationPath, 'utf8'));
+    if (!isRecord(parsed) || !isRecord(parsed.projects)) {
+        return undefined;
+    }
+    const firstProject = Object.values(parsed.projects)[0];
+    if (!isRecord(firstProject) || !isRecord(firstProject.architect)) {
+        return undefined;
+    }
+    const serveApplication = firstProject.architect['serve-application'];
+    if (!isRecord(serveApplication) || !isRecord(serveApplication.options)) {
+        return undefined;
+    }
+    const port = serveApplication.options.port;
+    return typeof port === 'number' ? port : undefined;
+}
+function findAvailablePort(configuration) {
+    const occupiedPorts = configuration.microfrontends
+        .map((microfrontend) => extractPort(microfrontend.developmentRemoteEntry))
+        .filter((port) => port !== undefined);
+    let candidate = 4300;
+    while (occupiedPorts.includes(candidate)) {
+        candidate += 100;
+    }
+    return candidate;
+}
+function extractPort(remoteEntry) {
+    try {
+        const port = new URL(remoteEntry).port;
+        return port === '' ? undefined : Number(port);
+    }
+    catch {
+        return undefined;
+    }
+}
+function validatePort(port) {
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error('El puerto debe ser un número entre 1 y 65535.');
+    }
+}
+function toConfigurationPath(applicationRoot, targetPath) {
+    return relative(applicationRoot, targetPath).split(sep).join('/');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/application/shell-configuration.d.ts

@@ -0,0 +1,2 @@
+import type { OpenMovaApplicationConfiguration } from '../types.js';
+export declare function synchronizeShellConfiguration(applicationRoot: string, configuration: OpenMovaApplicationConfiguration): void;

package/dist/application/shell-configuration.js

@@ -0,0 +1,30 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function synchronizeShellConfiguration(applicationRoot, configuration) {
+    const manifest = Object.fromEntries(configuration.microfrontends.map((microfrontend) => [
+        microfrontend.remoteName,
+        microfrontend.developmentRemoteEntry,
+    ]));
+    writeFileSync(join(applicationRoot, 'src', 'assets', 'federation.manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    writeFileSync(join(applicationRoot, 'src', 'app', 'application.config.ts'), renderApplicationConfiguration(configuration), 'utf8');
+}
+function renderApplicationConfiguration(configuration) {
+    const entries = configuration.microfrontends
+        .map((microfrontend) => `  {
+    path: ${JSON.stringify(microfrontend.route)},
+    remote: ${JSON.stringify(microfrontend.remoteName)},
+    exposedModule: './Routes',
+  },`)
+        .join('\n');
+    return `export interface MicrofrontendDefinition {
+  readonly path: string;
+  readonly remote: string;
+  readonly exposedModule: './Routes';
+}
+
+// Este fichero lo mantiene el CLI a partir de mova.config.json.
+export const microfrontends: readonly MicrofrontendDefinition[] = [
+${entries}
+];
+`;
+}

package/dist/application/shell-repository.d.ts

@@ -0,0 +1,10 @@
+export declare const SHELL_REPOSITORY = "https://github.com/rgarciadelongoria/open-mova.git";
+export interface ShellVersion {
+    readonly repository: string;
+    readonly version: string;
+    readonly commit: string;
+}
+export declare function listShellVersions(): string[];
+export declare function downloadShell(destination: string, requestedVersion?: string): ShellVersion;
+export declare function downloadTaggedProject(project: 'open-mova-shell' | 'open-mova-mf-template' | 'open-mova-core', destination: string, requestedVersion?: string): ShellVersion;
+export declare function configureDownloadedShell(destination: string, applicationName: string, includesStarterMicrofrontend: boolean): void;