@open-mova/cli 0.1.21 → 0.1.22

package/README.md

@@ -23,6 +23,10 @@ El CLI descarga la shell, el core y la plantilla de microfrontales desde tags es
 - [`mova shell`](#mova-shell)
 - [`mova shell versions`](#mova-shell-versions)
 - [`mova cap`](#mova-cap)
+- [`mova cap list`](#mova-cap-list)
+- [`mova cap enable`](#mova-cap-enable)
+- [`mova cap disable`](#mova-cap-disable)
+- [`mova cap doctor`](#mova-cap-doctor)
 - [`mova cap add`](#mova-cap-add)
 - [`mova cap sync`](#mova-cap-sync)
 - [`mova cap open`](#mova-cap-open)
@@ -229,6 +233,47 @@ mova cap add android
 mova cap add ios
 ```
 
+### `mova cap list`
+
+Muestra el catálogo de capacidades nativas. `✓` indica que la capacidad está
+habilitada y `○` que está disponible pero no instalada.
+
+```bash
+mova cap list
+```
+
+### `mova cap enable`
+
+Habilita una o varias capacidades. Instala únicamente sus paquetes npm,
+actualiza `mova.config.json`, regenera el provider Angular y sincroniza las
+plataformas nativas que ya existan.
+
+```bash
+mova cap enable camera device geolocation
+```
+
+### `mova cap disable`
+
+Deshabilita capacidades y elimina los paquetes que ninguna otra capacidad
+activa necesita. El contrato de Core permanece disponible, pero
+`isAvailable()` devuelve `false` y cualquier operación explica cómo volver a
+habilitar la capacidad.
+
+```bash
+mova cap disable geolocation
+```
+
+### `mova cap doctor`
+
+Muestra plataformas compatibles, permisos, SDK mínimo y configuración manual
+de las capacidades activas.
+
+```bash
+mova cap doctor
+mova cap doctor android
+mova cap doctor ios
+```
+
 ### `mova cap sync`
 
 Sincroniza la shell compilada, los recursos y los plugins con la plataforma. Sin plataforma, sincroniza todas las plataformas añadidas.
@@ -238,9 +283,8 @@ mova cap sync android
 mova cap sync
 ```
 
-En Android, el CLI aplica también los requisitos técnicos de los plugins
-incluidos por la shell: configura el repositorio AAR de Background Runner y
-eleva `minSdkVersion` a 28 cuando está instalado Local LLM. También añade la
+En Android, el CLI aplica los requisitos declarados por las capacidades
+activas: permisos, SDK mínimo, el repositorio AAR de Background Runner y la
 entrada obligatoria de Google Maps. Para usar mapas reales, define una clave
 restringida antes de sincronizar:
 
@@ -274,7 +318,8 @@ mova cap open ios
 ### `mova cap`
 
 Es el grupo de comandos para preparar y abrir los proyectos nativos de
-Capacitor. Sus subcomandos son `add`, `sync` y `open`.
+Capacitor. También permite seleccionar capacidades mediante `list`, `enable`,
+`disable` y `doctor`.
 
 ## Flujo habitual
 
@@ -283,6 +328,7 @@ mova create mi-aplicacion
 cd mi-aplicacion
 npm install
 npm --prefix mfs/home install
+mova cap enable camera device
 mova start
 ```
 
@@ -316,6 +362,14 @@ aplica la configuración específica de los plugins instalados:
 mova cap add android
 ```
 
+Antes o después de añadir la plataforma puedes habilitar solo lo que use la
+aplicación:
+
+```bash
+mova cap enable camera device
+mova cap doctor android
+```
+
 Si utilizas Google Maps, proporciona la clave antes de sincronizar:
 
 ```bash
@@ -369,6 +423,13 @@ mova cap add ios
 mova cap sync ios
 ```
 
+Activa previamente las capacidades que necesites y revisa sus requisitos:
+
+```bash
+mova cap enable camera device
+mova cap doctor ios
+```
+
 Revisa en Xcode los permisos y la configuración nativa que necesiten los
 plugins utilizados, por ejemplo las descripciones de cámara, fotos,
 geolocalización o notificaciones en `Info.plist` y los entitlements

package/dist/application/android-configuration.js

@@ -1,8 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { readNativeCapabilityCatalog } from './shell-configuration.js';
 export function configureAndroidProject(applicationRoot, configuration) {
     const packageConfiguration = readPackageConfiguration(applicationRoot);
-    configureMinimumSdk(applicationRoot, packageConfiguration);
+    configureMinimumSdk(applicationRoot, configuration);
+    configurePermissions(applicationRoot, configuration);
     configureBackgroundRunner(applicationRoot, packageConfiguration);
     configureGoogleMaps(applicationRoot, configuration, packageConfiguration);
 }
@@ -42,8 +44,12 @@ function configureGoogleMaps(applicationRoot, configuration, packageConfiguratio
     ].join('\n');
     writeFileSync(join(valuesDirectory, 'open_mova_google_maps.xml'), resource, 'utf8');
 }
-function configureMinimumSdk(applicationRoot, packageConfiguration) {
-    if (!packageConfiguration.dependencies?.['@capacitor/local-llm'])
+function configureMinimumSdk(applicationRoot, configuration) {
+    const enabled = new Set(configuration.native?.capabilities ?? []);
+    const requiredMinimumSdk = Math.max(0, ...readNativeCapabilityCatalog(applicationRoot)
+        .capabilities.filter((capability) => enabled.has(capability.name))
+        .map((capability) => capability.minimumAndroidSdk ?? 0));
+    if (requiredMinimumSdk === 0)
         return;
     const variablesPath = join(applicationRoot, 'android', 'variables.gradle');
     if (!existsSync(variablesPath)) {
@@ -55,9 +61,28 @@ function configureMinimumSdk(applicationRoot, packageConfiguration) {
     if (!Number.isFinite(currentMinimumSdk)) {
         throw new Error('No se ha encontrado minSdkVersion en android/variables.gradle.');
     }
-    if (currentMinimumSdk >= 28)
+    if (currentMinimumSdk >= requiredMinimumSdk)
         return;
-    writeFileSync(variablesPath, variables.replace(minimumSdkPattern, 'minSdkVersion = 28'), 'utf8');
+    writeFileSync(variablesPath, variables.replace(minimumSdkPattern, `minSdkVersion = ${requiredMinimumSdk}`), 'utf8');
+}
+function configurePermissions(applicationRoot, configuration) {
+    const manifestPath = join(applicationRoot, 'android', 'app', 'src', 'main', 'AndroidManifest.xml');
+    if (!existsSync(manifestPath))
+        return;
+    const enabled = new Set(configuration.native?.capabilities ?? []);
+    const permissions = [
+        ...new Set(readNativeCapabilityCatalog(applicationRoot)
+            .capabilities.filter((capability) => enabled.has(capability.name))
+            .flatMap((capability) => capability.permissions?.android ?? [])),
+    ];
+    let manifest = readFileSync(manifestPath, 'utf8');
+    const applicationTag = /\s*<application\b/;
+    for (const permission of permissions) {
+        if (manifest.includes(`android:name="${permission}"`))
+            continue;
+        manifest = manifest.replace(applicationTag, `\n    <uses-permission android:name="${permission}" />\n\n    <application`);
+    }
+    writeFileSync(manifestPath, manifest, 'utf8');
 }
 function configureBackgroundRunner(applicationRoot, packageConfiguration) {
     if (!packageConfiguration.dependencies?.['@capacitor/background-runner'])

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

@@ -1,4 +1,4 @@
-export declare const LATEST_CONFIGURATION_SCHEMA_VERSION = 2;
+export declare const LATEST_CONFIGURATION_SCHEMA_VERSION = 3;
 export interface ConfigurationMigrationResult {
     readonly value: unknown;
     readonly migrations: readonly string[];

package/dist/application/configuration-migrations.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-export const LATEST_CONFIGURATION_SCHEMA_VERSION = 2;
+export const LATEST_CONFIGURATION_SCHEMA_VERSION = 3;
 export function migrateConfiguration(value, applicationRoot) {
     if (!isRecord(value) || typeof value.schemaVersion !== 'number') {
         return { value, migrations: [] };
@@ -14,8 +14,54 @@ export function migrateConfiguration(value, applicationRoot) {
         migrated = migrateVersionOne(migrated, applicationRoot);
         migrations.push('1 → 2: declarar la compatibilidad de Core de cada microfrontal');
     }
+    if (migrated.schemaVersion === 2) {
+        migrated = migrateVersionTwo(migrated, applicationRoot);
+        migrations.push('2 → 3: declarar las capacidades nativas habilitadas');
+    }
     return { value: migrated, migrations };
 }
+function migrateVersionTwo(configuration, applicationRoot) {
+    const currentNative = isRecord(configuration.native) ? configuration.native : {};
+    return {
+        ...configuration,
+        schemaVersion: 3,
+        native: {
+            ...currentNative,
+            // Las aplicaciones anteriores incluían todos los plugins. Se conservan
+            // explícitamente hasta que el equipo decida deshabilitarlos.
+            capabilities: readLegacyCapabilities(configuration, applicationRoot),
+        },
+    };
+}
+function readLegacyCapabilities(configuration, applicationRoot) {
+    if (isRecord(configuration.native) && Array.isArray(configuration.native.capabilities)) {
+        return configuration.native.capabilities.filter((capability) => typeof capability === 'string');
+    }
+    const packageConfiguration = readJson(join(applicationRoot, 'package.json'));
+    const catalog = readJson(join(applicationRoot, 'native-capabilities.catalog.json'));
+    const dependencies = isRecord(packageConfiguration?.dependencies)
+        ? packageConfiguration.dependencies
+        : {};
+    if (!Array.isArray(catalog?.capabilities))
+        return [];
+    return catalog.capabilities
+        .filter((capability) => isRecord(capability) &&
+        typeof capability.name === 'string' &&
+        typeof capability.package === 'string')
+        .filter((capability) => capability.package === '@capacitor/core' || capability.package in dependencies)
+        .map((capability) => capability.name);
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const value = JSON.parse(readFileSync(path, 'utf8'));
+        return isRecord(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function migrateVersionOne(configuration, applicationRoot) {
     const shellCoreVersion = readCoreVersion(join(applicationRoot, 'package.json'));
     const microfrontends = Array.isArray(configuration.microfrontends)

package/dist/application/configuration.js

@@ -83,19 +83,25 @@ function validateApplicationConfiguration(value, configurationPath) {
         if (!isRecord(value.native)) {
             throw new Error(`${configurationPath} contiene una configuración nativa no válida.`);
         }
+        if (!Array.isArray(value.native.capabilities) ||
+            value.native.capabilities.some((capability) => typeof capability !== 'string')) {
+            throw new Error(`${configurationPath} contiene capacidades nativas no válidas.`);
+        }
+        const capabilities = [...new Set(value.native.capabilities)].sort();
         if (value.native.googleMaps !== undefined) {
             if (!isRecord(value.native.googleMaps) ||
                 typeof value.native.googleMaps.androidApiKey !== 'string') {
                 throw new Error(`${configurationPath} contiene una clave de Google Maps no válida.`);
             }
             native = {
+                capabilities,
                 googleMaps: {
                     androidApiKey: value.native.googleMaps.androidApiKey,
                 },
             };
         }
         else {
-            native = {};
+            native = { capabilities };
         }
     }
     const microfrontends = value.microfrontends.map((entry) => validateMicrofrontend(entry, configurationPath));

package/dist/application/native-capabilities.d.ts

@@ -0,0 +1,15 @@
+import type { OpenMovaApplicationConfiguration } from '../types.js';
+import { type NativeCapabilityDefinition } from './shell-configuration.js';
+export interface NativeCapabilityStatus {
+    readonly definition: NativeCapabilityDefinition;
+    readonly enabled: boolean;
+}
+export declare function listNativeCapabilities(applicationRoot: string): readonly NativeCapabilityStatus[];
+export declare function enableNativeCapabilities(applicationRoot: string, requestedNames: readonly string[]): OpenMovaApplicationConfiguration;
+export declare function disableNativeCapabilities(applicationRoot: string, requestedNames: readonly string[]): OpenMovaApplicationConfiguration;
+export declare function diagnoseNativeCapabilities(applicationRoot: string, platform?: 'android' | 'ios'): readonly string[];
+/**
+ * Recompone las dependencias seleccionables después de actualizar la shell.
+ * No instala paquetes: el flujo de update regenera después el lockfile.
+ */
+export declare function synchronizeNativeCapabilityDependencies(applicationRoot: string, configuration: OpenMovaApplicationConfiguration): void;

package/dist/application/native-capabilities.js

@@ -0,0 +1,143 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { npmCommand, useCommandShell } from '../utils/platform.js';
+import { readApplicationConfiguration, writeApplicationConfiguration } from './configuration.js';
+import { readNativeCapabilityCatalog, synchronizeShellConfiguration, } from './shell-configuration.js';
+export function listNativeCapabilities(applicationRoot) {
+    const configuration = readApplicationConfiguration(applicationRoot);
+    const enabled = new Set(configuration.native?.capabilities ?? []);
+    return readNativeCapabilityCatalog(applicationRoot).capabilities.map((definition) => ({
+        definition,
+        enabled: enabled.has(definition.name),
+    }));
+}
+export function enableNativeCapabilities(applicationRoot, requestedNames) {
+    const configuration = readApplicationConfiguration(applicationRoot);
+    const definitions = resolveDefinitions(applicationRoot, requestedNames);
+    const enabled = new Set(configuration.native?.capabilities ?? []);
+    const newDefinitions = definitions.filter((definition) => !enabled.has(definition.name));
+    for (const definition of definitions)
+        enabled.add(definition.name);
+    installPackages(applicationRoot, newDefinitions);
+    return persistCapabilities(applicationRoot, configuration, [...enabled]);
+}
+export function disableNativeCapabilities(applicationRoot, requestedNames) {
+    const configuration = readApplicationConfiguration(applicationRoot);
+    const definitions = resolveDefinitions(applicationRoot, requestedNames);
+    const currentlyEnabled = new Set(configuration.native?.capabilities ?? []);
+    const activeDefinitions = definitions.filter((definition) => currentlyEnabled.has(definition.name));
+    const disabled = new Set(definitions.map((definition) => definition.name));
+    const remainingNames = (configuration.native?.capabilities ?? []).filter((name) => !disabled.has(name));
+    const remainingDefinitions = remainingNames.length > 0 ? resolveDefinitions(applicationRoot, remainingNames) : [];
+    const retainedPackages = new Set(remainingDefinitions.map((definition) => definition.package));
+    const packagesToRemove = [
+        ...new Set(activeDefinitions
+            .map((definition) => definition.package)
+            .filter((packageName) => packageName !== '@capacitor/core')),
+    ].filter((packageName) => !retainedPackages.has(packageName));
+    uninstallPackages(applicationRoot, packagesToRemove);
+    return persistCapabilities(applicationRoot, configuration, remainingNames);
+}
+export function diagnoseNativeCapabilities(applicationRoot, platform) {
+    const statuses = listNativeCapabilities(applicationRoot).filter((status) => status.enabled);
+    const messages = [];
+    if (statuses.length === 0) {
+        return ['No hay capacidades nativas habilitadas.'];
+    }
+    for (const { definition } of statuses) {
+        if (platform && !definition.platforms.includes(platform)) {
+            messages.push(`⚠ ${definition.name}: no es compatible con ${platform}.`);
+            continue;
+        }
+        const requirements = [];
+        if (platform === 'android' && definition.minimumAndroidSdk) {
+            requirements.push(`Android SDK mínimo ${definition.minimumAndroidSdk}`);
+        }
+        if (platform && definition.permissions?.[platform]?.length) {
+            requirements.push(`permisos: ${definition.permissions[platform]?.join(', ')}`);
+        }
+        if (definition.notes?.length)
+            requirements.push(...definition.notes);
+        messages.push(requirements.length > 0
+            ? `• ${definition.name}: ${requirements.join('; ')}`
+            : `✓ ${definition.name}: sin configuración adicional declarada${platform ? ` para ${platform}` : ''}.`);
+    }
+    return messages;
+}
+/**
+ * Recompone las dependencias seleccionables después de actualizar la shell.
+ * No instala paquetes: el flujo de update regenera después el lockfile.
+ */
+export function synchronizeNativeCapabilityDependencies(applicationRoot, configuration) {
+    const packagePath = join(applicationRoot, 'package.json');
+    const packageConfiguration = JSON.parse(readFileSync(packagePath, 'utf8'));
+    const dependencies = { ...(packageConfiguration.dependencies ?? {}) };
+    const catalog = readNativeCapabilityCatalog(applicationRoot);
+    const enabled = new Set(configuration.native?.capabilities ?? []);
+    const selectablePackages = new Set(catalog.capabilities
+        .map((definition) => definition.package)
+        .filter((packageName) => packageName !== '@capacitor/core'));
+    for (const packageName of selectablePackages)
+        delete dependencies[packageName];
+    for (const definition of catalog.capabilities) {
+        if (enabled.has(definition.name) &&
+            definition.package !== '@capacitor/core' &&
+            definition.version) {
+            dependencies[definition.package] = definition.version;
+        }
+    }
+    packageConfiguration.dependencies = Object.fromEntries(Object.entries(dependencies).sort(([first], [second]) => first.localeCompare(second)));
+    writeFileSync(packagePath, `${JSON.stringify(packageConfiguration, null, 2)}\n`, 'utf8');
+}
+function persistCapabilities(applicationRoot, configuration, capabilities) {
+    const updated = {
+        ...configuration,
+        native: {
+            ...configuration.native,
+            capabilities: [...new Set(capabilities)].sort(),
+        },
+    };
+    writeApplicationConfiguration(applicationRoot, updated);
+    synchronizeShellConfiguration(applicationRoot, updated);
+    return updated;
+}
+function resolveDefinitions(applicationRoot, names) {
+    if (names.length === 0)
+        throw new Error('Indica al menos una capacidad nativa.');
+    const catalog = readNativeCapabilityCatalog(applicationRoot);
+    const definitionsByName = new Map(catalog.capabilities.map((definition) => [definition.name, definition]));
+    const unknown = names.filter((name) => !definitionsByName.has(name));
+    if (unknown.length > 0) {
+        throw new Error(`Capacidades desconocidas: ${unknown.join(', ')}. Usa "mova cap list" para consultar el catálogo.`);
+    }
+    return names.map((name) => definitionsByName.get(name));
+}
+function installPackages(applicationRoot, definitions) {
+    const packages = [
+        ...new Set(definitions
+            .filter((definition) => definition.package !== '@capacitor/core')
+            .map((definition) => `${definition.package}@${definition.version ?? 'latest'}`)),
+    ];
+    if (packages.length > 0)
+        runNpm(applicationRoot, ['install', '--save', ...packages]);
+}
+function uninstallPackages(applicationRoot, packages) {
+    if (packages.length > 0)
+        runNpm(applicationRoot, ['uninstall', '--save', ...packages]);
+}
+function runNpm(applicationRoot, arguments_) {
+    if (!existsSync(join(applicationRoot, 'package.json'))) {
+        throw new Error(`No se encuentra package.json en ${applicationRoot}.`);
+    }
+    const result = spawnSync(npmCommand(), arguments_, {
+        cwd: applicationRoot,
+        stdio: 'inherit',
+        shell: useCommandShell(),
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0) {
+        throw new Error(`${npmCommand()} ${arguments_.join(' ')} terminó con error.`);
+    }
+}

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

@@ -1,2 +1,22 @@
 import type { OpenMovaApplicationConfiguration } from '../types.js';
+export interface NativeCapabilityDefinition {
+    readonly name: string;
+    readonly implementation: string;
+    readonly exportName: string;
+    readonly package: string;
+    readonly version?: string;
+    readonly platforms: readonly ('android' | 'ios' | 'web')[];
+    readonly minimumAndroidSdk?: number;
+    readonly permissions?: {
+        readonly android?: readonly string[];
+        readonly ios?: readonly string[];
+    };
+    readonly notes?: readonly string[];
+}
+interface NativeCapabilityCatalog {
+    readonly schemaVersion: 1;
+    readonly capabilities: readonly NativeCapabilityDefinition[];
+}
 export declare function synchronizeShellConfiguration(applicationRoot: string, configuration: OpenMovaApplicationConfiguration): void;
+export declare function readNativeCapabilityCatalog(applicationRoot: string): NativeCapabilityCatalog;
+export {};

package/dist/application/shell-configuration.js

@@ -1,4 +1,4 @@
-import { writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 export function synchronizeShellConfiguration(applicationRoot, configuration) {
     const manifest = Object.fromEntries(configuration.microfrontends.map((microfrontend) => [
@@ -7,6 +7,55 @@ export function synchronizeShellConfiguration(applicationRoot, configuration) {
     ]));
     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');
+    synchronizeNativeCapabilities(applicationRoot, configuration);
+}
+export function readNativeCapabilityCatalog(applicationRoot) {
+    const catalogPath = join(applicationRoot, 'native-capabilities.catalog.json');
+    const catalog = JSON.parse(readFileSync(catalogPath, 'utf8'));
+    if (catalog.schemaVersion !== 1 || !Array.isArray(catalog.capabilities)) {
+        throw new Error(`${catalogPath} no contiene un catálogo de capacidades válido.`);
+    }
+    return catalog;
+}
+function synchronizeNativeCapabilities(applicationRoot, configuration) {
+    const catalog = readNativeCapabilityCatalog(applicationRoot);
+    const enabledNames = new Set(configuration.native?.capabilities ?? []);
+    const knownNames = new Set(catalog.capabilities.map((capability) => capability.name));
+    const unknownNames = [...enabledNames].filter((name) => !knownNames.has(name));
+    if (unknownNames.length > 0) {
+        throw new Error(`Capacidades nativas desconocidas: ${unknownNames.join(', ')}.`);
+    }
+    const enabled = catalog.capabilities.filter((capability) => enabledNames.has(capability.name));
+    const imports = enabled
+        .map((capability) => `import { ${capability.exportName} } from './${capability.implementation}';`)
+        .join('\n');
+    const entries = catalog.capabilities
+        .map((capability) => {
+        const value = enabledNames.has(capability.name)
+            ? capability.exportName
+            : `createUnavailableNativeCapability<NativeCapabilities[${JSON.stringify(capability.name)}]>(${JSON.stringify(capability.name)})`;
+        return `  ${capability.name}: ${value},`;
+    })
+        .join('\n');
+    const source = `import type { Provider } from '@angular/core';
+import { NATIVE_CAPABILITIES, type NativeCapabilities } from '@open-mova/core';
+import { createUnavailableNativeCapability } from './unavailable-native-capability';
+${imports ? `\n${imports}` : ''}
+
+// Generado por el CLI desde mova.config.json. No editar manualmente.
+const nativeCapabilities = {
+  version: 1,
+${entries}
+} satisfies NativeCapabilities;
+
+export function provideNativeCapabilities(): Provider {
+  return {
+    provide: NATIVE_CAPABILITIES,
+    useValue: nativeCapabilities,
+  };
+}
+`;
+    writeFileSync(join(applicationRoot, 'src', 'native-capabilities', 'native-capabilities.provider.ts'), source, 'utf8');
 }
 function renderApplicationConfiguration(configuration) {
     const entries = configuration.microfrontends

package/dist/application/shell-update.js

@@ -7,6 +7,7 @@ import { writeApplicationConfiguration } from './configuration.js';
 import { applyFileChanges, compareManagedFiles, comparePackageConfiguration, requireCleanGitRepository, } from './project-update.js';
 import { findIncompatibleMicrofrontends } from './core-compatibility.js';
 import { readRequiredCoreVersion } from './microfrontend-manifest.js';
+import { synchronizeNativeCapabilityDependencies } from './native-capabilities.js';
 const GENERATED_PATHS = new Set([
     'package.json',
     'package-lock.json',
@@ -83,6 +84,7 @@ export function applyShellUpdate(applicationRoot, configuration, plan) {
         ...configuration,
         shell: plan.target,
     };
+    synchronizeNativeCapabilityDependencies(applicationRoot, updatedConfiguration);
     writeApplicationConfiguration(applicationRoot, updatedConfiguration);
     synchronizeShellConfiguration(applicationRoot, updatedConfiguration);
 }

package/dist/commands/capacitor.js

@@ -3,9 +3,47 @@ import { existsSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { readApplicationConfiguration, requireApplicationRoot, } from '../application/configuration.js';
 import { configureAndroidProject } from '../application/android-configuration.js';
+import { diagnoseNativeCapabilities, disableNativeCapabilities, enableNativeCapabilities, listNativeCapabilities, } from '../application/native-capabilities.js';
 import { localBinaryName, npmCommand, useCommandShell } from '../utils/platform.js';
 export function registerCapacitorCommands(program) {
     const capacitor = program.command('cap').description('Prepara la shell para Android o iOS');
+    capacitor
+        .command('list')
+        .description('Lista las capacidades nativas disponibles y habilitadas')
+        .action(() => {
+        const root = requireApplicationRoot(process.cwd());
+        for (const { definition, enabled } of listNativeCapabilities(root)) {
+            console.log(`${enabled ? '✓' : '○'} ${definition.name} (${definition.platforms.join(', ')})`);
+        }
+    });
+    capacitor
+        .command('enable <capabilities...>')
+        .description('Instala y habilita capacidades nativas en la aplicación')
+        .action((capabilities) => {
+        const root = requireApplicationRoot(process.cwd());
+        enableNativeCapabilities(root, capabilities);
+        synchronizeExistingNativeProjects(root);
+        console.log(`Capacidades habilitadas: ${capabilities.join(', ')}.`);
+    });
+    capacitor
+        .command('disable <capabilities...>')
+        .description('Deshabilita capacidades y elimina los plugins que ya no se usan')
+        .action((capabilities) => {
+        const root = requireApplicationRoot(process.cwd());
+        disableNativeCapabilities(root, capabilities);
+        synchronizeExistingNativeProjects(root);
+        console.log(`Capacidades deshabilitadas: ${capabilities.join(', ')}.`);
+    });
+    capacitor
+        .command('doctor [platform]')
+        .description('Muestra requisitos y configuración pendiente de las capacidades')
+        .action((platform) => {
+        const root = requireApplicationRoot(process.cwd());
+        const selectedPlatform = platform ? parsePlatform(platform) : undefined;
+        for (const message of diagnoseNativeCapabilities(root, selectedPlatform)) {
+            console.log(message);
+        }
+    });
     capacitor
         .command('add <platform>')
         .description('Crea el proyecto nativo de la plataforma')
@@ -81,6 +119,15 @@ function configureExistingPlatforms(root, configuration) {
         configureNativePlatform(root, 'android', configuration);
     }
 }
+function synchronizeExistingNativeProjects(root) {
+    const platforms = ['android', 'ios'];
+    for (const platform of platforms) {
+        if (existsSync(join(root, platform))) {
+            runCapacitor(root, ['sync', platform]);
+            configureNativePlatform(root, platform, readApplicationConfiguration(root));
+        }
+    }
+}
 function configureNativePlatform(root, platform, configuration) {
     if (platform === 'android') {
         configureAndroidProject(root, configuration);

package/dist/commands/create.js

@@ -27,9 +27,10 @@ export function registerCreateCommand(program) {
             shellVersion = shell.version;
             configureDownloadedShell(temporaryApplication, applicationName, !options.empty);
             let configuration = {
-                schemaVersion: 2,
+                schemaVersion: 3,
                 name: applicationName,
                 shell,
+                native: { capabilities: [] },
                 microfrontends: [],
             };
             if (!options.empty) {

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 export interface OpenMovaApplicationConfiguration {
-    readonly schemaVersion: 2;
+    readonly schemaVersion: 3;
     readonly name: string;
     readonly shell?: {
         readonly repository: string;
@@ -11,6 +11,8 @@ export interface OpenMovaApplicationConfiguration {
     readonly microfrontends: readonly MicrofrontendConfiguration[];
 }
 export interface NativeConfiguration {
+    /** Capacidades instaladas y proporcionadas por la shell. */
+    readonly capabilities: readonly string[];
     readonly googleMaps?: {
         /** Clave de Android Maps. También puede venir de OPEN_MOVA_GOOGLE_MAPS_ANDROID_API_KEY. */
         readonly androidApiKey?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mova/cli",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "CLI para crear y mantener aplicaciones Open Mova",
   "license": "MIT",
   "author": "Open Mova contributors",