dhti-cli 0.8.0 → 1.0.1

package/dist/commands/conch.js

@@ -1,268 +1,203 @@
 import { Args, Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
-import { exec } from 'node:child_process';
+import { exec, spawn } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-// Helper function to escape shell arguments
-function escapeShellArg(arg) {
-    return `'${arg.replaceAll("'", "'\\''")}'`;
-}
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
 export default class Conch extends Command {
     static args = {
-        op: Args.string({ description: 'Operation to perform (install, uninstall or dev)' }),
+        op: Args.string({ description: 'Operation to perform (init, install, or start)' }),
     };
-    static description = 'Install or uninstall conchs to create a Docker image';
-    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static description = 'Initialize, install, or start OpenMRS frontend development';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> install -n my-app -w ~/projects',
+        '<%= config.bin %> <%= command.id %> init -n my-app -w ~/projects',
+        '<%= config.bin %> <%= command.id %> start -n my-app -w ~/projects',
+    ];
     static flags = {
-        branch: Flags.string({ char: 'b', default: 'develop', description: 'Branch to install from' }),
-        container: Flags.string({
-            char: 'c',
-            default: 'dhti-frontend-1',
-            description: 'Name of the container to copy the conch to while in dev mode',
+        branch: Flags.string({
+            char: 'b',
+            default: 'develop',
+            description: 'Branch to install from (for install operation)',
         }),
-        dev: Flags.string({ char: 'd', default: 'none', description: 'Dev folder to install' }),
         'dry-run': Flags.boolean({
             default: false,
             description: 'Show what changes would be made without actually making them',
         }),
-        git: Flags.string({ char: 'g', default: 'none', description: 'Github repository to install' }),
-        image: Flags.string({
-            char: 'i',
-            default: 'openmrs/openmrs-reference-application-3-frontend:3.0.0-beta.17',
-            description: 'Base image to use for the conch',
+        git: Flags.string({
+            char: 'g',
+            default: 'dermatologist/openmrs-esm-dhti-template',
+            description: 'GitHub repository to install (for install operation)',
         }),
-        local: Flags.string({ char: 'l', default: 'none', description: 'Local directory to install from' }),
-        name: Flags.string({ char: 'n', description: 'Name of the elixir' }),
-        repoVersion: Flags.string({ char: 'v', default: '1.0.0', description: 'Version of the conch' }),
-        subdirectory: Flags.string({
+        name: Flags.string({ char: 'n', description: 'Name of the conch' }),
+        sources: Flags.string({
             char: 's',
-            default: 'none',
-            description: 'Subdirectory in the repository to install from (for monorepos)',
+            description: 'Additional sources to include when starting (e.g., packages/esm-chatbot-agent)',
         }),
         workdir: Flags.string({
             char: 'w',
             default: `${os.homedir()}/dhti`,
-            description: 'Working directory to install the conch',
+            description: 'Working directory for the conch',
         }),
     };
     async run() {
         const { args, flags } = await this.parse(Conch);
-        // Resolve resources directory for both dev (src) and packaged (dist)
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        const RESOURCES_DIR = path.resolve(__dirname, '../resources');
-        if (!flags.name) {
-            console.log('Please provide a name for the conch');
-            this.exit(1);
-        }
-        // if arg is dev then copy to docker as below
-        // docker cp ../../openmrs-esm-genai/dist/. dhti-frontend-1:/usr/share/nginx/html/openmrs-esm-genai-1.0.0
-        // docker restart dhti-frontend-1
-        if (args.op === 'dev') {
-            const buildCommand = `cd ${flags.dev} && yarn build && docker cp dist/. ${flags.container}:/usr/share/nginx/html/${flags.name}-${flags.repoVersion}`;
-            const restartCommand = `docker restart ${flags.container}`;
+        if (args.op === 'init') {
+            // Validate required flags
+            if (!flags.workdir) {
+                console.error(chalk.red('Error: workdir flag is required for init operation'));
+                this.exit(1);
+            }
+            if (!flags.name) {
+                console.error(chalk.red('Error: name flag is required for init operation'));
+                this.exit(1);
+            }
+            const targetDir = path.join(flags.workdir, 'openmrs-esm-dhti');
             if (flags['dry-run']) {
-                console.log(chalk.yellow('[DRY RUN] Would execute commands:'));
-                console.log(chalk.cyan(`  ${buildCommand}`));
-                console.log(chalk.cyan(`  ${restartCommand}`));
+                console.log(chalk.yellow('[DRY RUN] Would execute init operation:'));
+                console.log(chalk.cyan(`  npx degit dermatologist/openmrs-esm-dhti ${targetDir}`));
+                console.log(chalk.cyan(`  Copy ${targetDir}/packages/esm-starter-app to ${targetDir}/packages/${flags.name}`));
                 return;
             }
-            console.log(buildCommand);
             try {
-                exec(buildCommand, (error, stdout, stderr) => {
-                    if (error) {
-                        console.error(`exec error: ${error}`);
-                        return;
-                    }
-                    console.log(`stdout: ${stdout}`);
-                    console.error(`stderr: ${stderr}`);
-                });
-                exec(restartCommand, (error, stdout, stderr) => {
-                    if (error) {
-                        console.error(`exec error: ${error}`);
-                        return;
-                    }
-                    console.log(`stdout: ${stdout}`);
-                    console.error(`stderr: ${stderr}`);
-                });
+                // Run npx degit to clone the dhti template
+                console.log(chalk.blue(`Initializing DHTI template in ${targetDir}...`));
+                const degitCommand = `npx degit dermatologist/openmrs-esm-dhti ${targetDir}`;
+                await execAsync(degitCommand);
+                console.log(chalk.green('✓ DHTI template cloned successfully'));
+                // Copy packages/esm-starter-app subdirectory to packages/<name>
+                const starterAppSource = path.join(targetDir, 'packages', 'esm-starter-app');
+                const targetPackageDir = path.join(targetDir, 'packages', flags.name);
+                if (fs.existsSync(starterAppSource)) {
+                    console.log(chalk.blue(`Copying esm-starter-app to packages/${flags.name}...`));
+                    fs.cpSync(starterAppSource, targetPackageDir, { recursive: true });
+                    console.log(chalk.green(`✓ esm-starter-app copied to packages/${flags.name}`));
+                }
+                else {
+                    console.log(chalk.yellow(`Warning: esm-starter-app not found at ${starterAppSource}`));
+                }
+                console.log(chalk.green(`\n✓ Initialization complete! Your workspace is ready at ${targetDir}`));
+                console.log(chalk.blue(`\nTo start development, run:`));
+                const startCmd = `dhti-cli conch start -w ${flags.workdir} -n ${flags.name}`;
+                console.log(chalk.cyan(`  ${startCmd}`));
             }
             catch (error) {
-                console.log('Error copying conch to container', error);
+                console.error(chalk.red('Error during initialization:'), error);
+                this.exit(1);
             }
             return;
         }
-        // Create a directory to install the elixir
-        if (!fs.existsSync(`${flags.workdir}/conch`)) {
-            if (flags['dry-run']) {
-                console.log(chalk.yellow(`[DRY RUN] Would create directory: ${flags.workdir}/conch`));
+        if (args.op === 'start') {
+            // Validate required flags
+            if (!flags.workdir) {
+                console.error(chalk.red('Error: workdir flag is required for start operation'));
+                this.exit(1);
             }
-            else {
-                fs.mkdirSync(`${flags.workdir}/conch`);
+            if (!flags.name) {
+                console.error(chalk.red('Error: name flag is required for start operation'));
+                this.exit(1);
             }
-        }
-        if (flags['dry-run']) {
-            console.log(chalk.yellow(`[DRY RUN] Would copy resources from ${RESOURCES_DIR}/spa to ${flags.workdir}/conch`));
-        }
-        else {
-            fs.cpSync(path.join(RESOURCES_DIR, 'spa'), `${flags.workdir}/conch`, { recursive: true });
-        }
-        // Rewrite files
-        const rewrite = () => {
-            flags.name = flags.name ?? 'openmrs-esm-genai';
+            const targetDir = path.join(flags.workdir, flags.name);
             if (flags['dry-run']) {
-                console.log(chalk.yellow('[DRY RUN] Would update configuration files:'));
-                console.log(chalk.cyan(`  - ${flags.workdir}/conch/def/importmap.json`));
-                if (args.op === 'install') {
-                    console.log(chalk.green(`    Add import: ${flags.name.replace('openmrs-', '@openmrs/')} -> ./${flags.name}-${flags.repoVersion}/${flags.name}.js`));
-                }
-                if (args.op === 'uninstall') {
-                    console.log(chalk.green(`    Remove import: ${flags.name.replace('openmrs-', '@openmrs/')}`));
-                }
-                console.log(chalk.cyan(`  - ${flags.workdir}/conch/def/spa-assemble-config.json`));
-                if (args.op === 'install') {
-                    console.log(chalk.green(`    Add module: ${flags.name.replace('openmrs-', '@openmrs/')} = ${flags.repoVersion}`));
-                }
-                if (args.op === 'uninstall') {
-                    console.log(chalk.green(`    Remove module: ${flags.name.replace('openmrs-', '@openmrs/')}`));
-                }
-                console.log(chalk.cyan(`  - ${flags.workdir}/conch/Dockerfile`));
-                console.log(chalk.green(`    Update with conch=${flags.name}, version=${flags.repoVersion}, image=${flags.image}`));
-                console.log(chalk.cyan(`  - ${flags.workdir}/conch/def/routes.registry.json`));
-                if (args.op === 'install') {
-                    console.log(chalk.green(`    Add routes for ${flags.name.replace('openmrs-', '@openmrs/')}`));
-                }
-                if (args.op === 'uninstall') {
-                    console.log(chalk.green(`    Remove routes for ${flags.name.replace('openmrs-', '@openmrs/')}`));
+                console.log(chalk.yellow('[DRY RUN] Would execute start operation:'));
+                console.log(chalk.cyan(`  cd ${targetDir}`));
+                let dryRunCommand = 'corepack enable && yarn install && yarn start';
+                if (flags.sources) {
+                    dryRunCommand += ` --sources '${flags.sources}'`;
                 }
+                console.log(chalk.cyan(`  ${dryRunCommand}`));
                 return;
             }
-            // Read and process importmap.json
-            const importmap = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/def/importmap.json`, 'utf8'));
-            if (args.op === 'install')
-                importmap.imports[flags.name.replace('openmrs-', '@openmrs/')] = `./${flags.name}-${flags.repoVersion}/${flags.name}.js`;
-            if (args.op === 'uninstall')
-                delete importmap.imports[flags.name.replace('openmrs-', '@openmrs/')];
-            fs.writeFileSync(`${flags.workdir}/conch/def/importmap.json`, JSON.stringify(importmap, null, 2));
-            // Read and process spa-assemble-config.json
-            const spaAssembleConfig = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/def/spa-assemble-config.json`, 'utf8'));
-            if (args.op === 'install')
-                spaAssembleConfig.frontendModules[flags.name.replace('openmrs-', '@openmrs/')] = `${flags.repoVersion}`;
-            if (args.op === 'uninstall')
-                delete spaAssembleConfig.frontendModules[flags.name.replace('openmrs-', '@openmrs/')];
-            fs.writeFileSync(`${flags.workdir}/conch/def/spa-assemble-config.json`, JSON.stringify(spaAssembleConfig, null, 2));
-            // Read and process Dockerfile
-            let dockerfile = fs.readFileSync(`${flags.workdir}/conch/Dockerfile`, 'utf8');
-            dockerfile = dockerfile
-                .replaceAll('conch', flags.name)
-                .replaceAll('version', flags.repoVersion)
-                .replaceAll('server-image', flags.image);
-            fs.writeFileSync(`${flags.workdir}/conch/Dockerfile`, dockerfile);
-            // Read routes.json
-            const routes = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/${flags.name}/src/routes.json`, 'utf8'));
-            // Add to routes.registry.json
-            const registry = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/def/routes.registry.json`, 'utf8'));
-            if (args.op === 'install')
-                registry[flags.name.replace('openmrs-', '@openmrs/')] = routes;
-            if (args.op === 'uninstall')
-                delete registry[flags.name.replace('openmrs-', '@openmrs/')];
-            fs.writeFileSync(`${flags.workdir}/conch/def/routes.registry.json`, JSON.stringify(registry, null, 2));
-        };
-        if (flags.git !== 'none') {
-            let cloneCommand;
-            let checkoutCommand;
-            if (flags.subdirectory === 'none') {
-                cloneCommand = `git clone ${escapeShellArg(flags.git)} ${escapeShellArg(`${flags.workdir}/conch/${flags.name}`)}`;
-                checkoutCommand = `cd ${escapeShellArg(`${flags.workdir}/conch/${flags.name}`)} && git checkout ${escapeShellArg(flags.branch)}`;
-            }
-            else {
-                // Use sparse checkout for subdirectory - broken into steps for readability and security
-                const targetDir = `${flags.workdir}/conch/${flags.name}`;
-                const escapedDir = escapeShellArg(targetDir);
-                const escapedGit = escapeShellArg(flags.git);
-                const escapedBranch = escapeShellArg(flags.branch);
-                const escapedSubdir = escapeShellArg(flags.subdirectory);
-                // Build sparse checkout command with proper escaping
-                const initCommand = `mkdir -p ${escapedDir} && cd ${escapedDir} && git init`;
-                const remoteCommand = `git remote add origin ${escapedGit}`;
-                const sparseCommand = `git config core.sparseCheckout true`;
-                // Don't escape the glob pattern itself, only the subdirectory name
-                const patternCommand = `echo ${escapedSubdir}/'*' >> .git/info/sparse-checkout`;
-                const fetchCommand = `git fetch --depth=1 origin ${escapedBranch}`;
-                const checkoutCmd = `git checkout ${escapedBranch}`;
-                // Use bash's dotglob to include hidden files, and handle the case when no files exist
-                const moveCommand = `bash -c "shopt -s dotglob; if [ -d ${escapedSubdir} ]; then mv ${escapedSubdir}/* . 2>/dev/null || true; fi"`;
-                const cleanupCommand = `rm -rf ${escapedSubdir}`;
-                cloneCommand = `${initCommand} && ${remoteCommand} && ${sparseCommand} && ${patternCommand} && ${fetchCommand} && ${checkoutCmd} && ${moveCommand} && ${cleanupCommand}`;
-                checkoutCommand = `cd ${escapedDir} && echo "Sparse checkout complete"`;
+            // Check if directory exists (not in dry-run mode)
+            if (!fs.existsSync(targetDir)) {
+                console.error(chalk.red(`Error: Directory does not exist: ${targetDir}`));
+                console.log(chalk.yellow(`Run 'dhti-cli conch init -n ${flags.name} -w ${flags.workdir}' first`));
+                this.exit(1);
             }
-            if (flags['dry-run']) {
-                console.log(chalk.yellow('[DRY RUN] Would execute git commands:'));
-                if (flags.subdirectory === 'none') {
-                    console.log(chalk.cyan(`  ${cloneCommand}`));
-                    console.log(chalk.cyan(`  ${checkoutCommand}`));
-                }
-                else {
-                    console.log(chalk.cyan(`  Sparse checkout: ${flags.subdirectory} from ${flags.git}`));
-                }
-                rewrite();
-                return;
-            }
-            // git clone the repository
-            exec(cloneCommand, (error, stdout, stderr) => {
-                if (error) {
-                    console.error(`exec error: ${error}`);
-                    return;
+            try {
+                console.log(chalk.blue(`Starting OpenMRS development server in ${targetDir}...`));
+                console.log(chalk.yellow('Press Ctrl-C to stop\n'));
+                // Build the start command with sources flag if provided
+                let startCommand = 'corepack enable && yarn install && yarn start';
+                if (flags.sources) {
+                    startCommand += ` --sources '${flags.sources}'`;
                 }
-                // Checkout the branch (or confirm sparse checkout)
-                exec(checkoutCommand, (error, stdout, stderr) => {
-                    if (error) {
-                        console.error(`exec error: ${error}`);
-                        return;
+                // Spawn corepack enable && yarn install && yarn start with stdio inheritance to show output and allow Ctrl-C
+                const child = spawn(startCommand, {
+                    cwd: targetDir,
+                    shell: true,
+                    stdio: 'inherit',
+                });
+                // Handle process exit
+                child.on('exit', (code) => {
+                    if (code === 0) {
+                        console.log(chalk.green('\n✓ Development server stopped'));
+                    }
+                    else if (code !== null) {
+                        console.log(chalk.yellow(`\nDevelopment server exited with code ${code}`));
                     }
-                    rewrite();
-                    console.log(`stdout: ${stdout}`);
-                    console.error(`stderr: ${stderr}`);
                 });
-                console.log(`stdout: ${stdout}`);
-                console.error(`stderr: ${stderr}`);
-            });
-        }
-        // If flags.dev is not none, copy the dev folder to the conch directory
-        if (flags.dev !== 'none' && args.op !== 'dev') {
-            if (flags['dry-run']) {
-                console.log(chalk.yellow(`[DRY RUN] Would copy ${flags.dev} to ${flags.workdir}/conch/${flags.name}`));
-                rewrite();
+                // Handle errors
+                child.on('error', (error) => {
+                    console.error(chalk.red('Error starting development server:'), error);
+                    this.exit(1);
+                });
+                // Wait for the child process to complete
+                await new Promise((resolve) => {
+                    child.on('close', () => resolve());
+                });
             }
-            else {
-                fs.cpSync(flags.dev, `${flags.workdir}/conch/${flags.name}`, { recursive: true });
-                rewrite();
+            catch (error) {
+                console.error(chalk.red('Error during start:'), error);
+                this.exit(1);
             }
+            return;
         }
-        // If flags.local is not none, copy the local directory to the conch directory
-        if (flags.local !== 'none' && args.op !== 'dev') {
-            const absolutePath = path.isAbsolute(flags.local) ? flags.local : path.resolve(process.cwd(), flags.local);
-            // Validate that the path exists and is a directory (skip validation in dry-run mode)
-            if (!flags['dry-run']) {
-                if (!fs.existsSync(absolutePath)) {
-                    console.error(chalk.red(`Error: Local directory does not exist: ${absolutePath}`));
-                    this.exit(1);
-                }
-                const stats = fs.statSync(absolutePath);
-                if (!stats.isDirectory()) {
-                    console.error(chalk.red(`Error: Path is not a directory: ${absolutePath}`));
-                    this.exit(1);
-                }
+        if (args.op === 'install') {
+            // Validate required flags
+            if (!flags.workdir) {
+                console.error(chalk.red('Error: workdir flag is required for install operation'));
+                this.exit(1);
+            }
+            if (!flags.name) {
+                console.error(chalk.red('Error: name flag is required for install operation'));
+                this.exit(1);
+            }
+            // Warn if sources flag is used with install (not applicable)
+            if (flags.sources) {
+                console.warn(chalk.yellow('Warning: --sources flag is not applicable for install operation. It will be ignored.'));
+                console.warn(chalk.yellow('Use --sources with the start operation instead.'));
             }
+            const targetDir = path.join(flags.workdir, flags.name);
+            const degitSource = `${flags.git}#${flags.branch}`;
             if (flags['dry-run']) {
-                console.log(chalk.yellow(`[DRY RUN] Would copy ${absolutePath} to ${flags.workdir}/conch/${flags.name}`));
-                rewrite();
+                console.log(chalk.yellow('[DRY RUN] Would execute install operation:'));
+                console.log(chalk.cyan(`  npx degit ${degitSource} ${targetDir}`));
+                return;
+            }
+            try {
+                console.log(chalk.blue(`Installing from ${degitSource} to ${targetDir}...`));
+                const degitCommand = `npx degit ${degitSource} ${targetDir}`;
+                await execAsync(degitCommand);
+                console.log(chalk.green('✓ Repository cloned successfully'));
+                console.log(chalk.green(`\n✓ Installation complete! Your app is ready at ${targetDir}`));
+                console.log(chalk.blue(`\nTo start development, run:`));
+                let startCmd = `dhti-cli conch start -n ${flags.name} -w ${flags.workdir}`;
+                if (flags.sources) {
+                    startCmd += ` -s '${flags.sources}'`;
+                }
+                console.log(chalk.cyan(`  ${startCmd}`));
             }
-            else {
-                fs.cpSync(absolutePath, `${flags.workdir}/conch/${flags.name}`, { recursive: true });
-                rewrite();
+            catch (error) {
+                console.error(chalk.red('Error during installation:'), error);
+                this.exit(1);
             }
+            return;
         }
+        // If no valid operation is provided
+        console.error(chalk.red('Error: Invalid operation. Use "install", "init", or "start"'));
+        this.exit(1);
     }
 }

package/dist/commands/elixir.d.ts

@@ -10,6 +10,8 @@ export default class Elixir extends Command {
         container: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         dev: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        elixir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        fhir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         git: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         local: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;