feat: Improved the display for test. Added linux support on a macOS host.

Author: kevinwang5658

src/commands/test.ts

@@ -1,11 +1,13 @@
 import { Args, Flags } from '@oclif/core'
 import chalk from 'chalk';
+import { OS } from 'codify-schemas';
+import os from 'node:os';
 
 import { BaseCommand } from '../common/base-command.js';
-import { ApplyOrchestrator } from '../orchestrators/apply.js';
+import { ctx } from '../events/context.js';
 import { TestOrchestrator } from '../orchestrators/test.js';
 
-export default class Apply extends BaseCommand {
+export default class Test extends BaseCommand {
   static description =
 `Install or update resources on the system based on a codify.jsonc file.
 
@@ -26,6 +28,12 @@ For more information, visit: https://docs.codifycli.com/commands/apply
       description: 'Automatically use this password for any handlers that require elevated permissions.',
       char: 'S'
     }),
+    'operatingSystem': Flags.string({
+      options: ['macOS', 'linux'],
+      optional: true,
+      description: 'Operating system to use for the test VM. Defaults to the host operating system.',
+      char: 'o',
+    }),
   }
 
   static args = {
@@ -40,20 +48,25 @@ For more information, visit: https://docs.codifycli.com/commands/apply
   ]
 
   async init(): Promise<void> {
-    console.log('Running Codify apply...')
+    ctx.log('Running Codify test...')
     return super.init();
   }
 
   public async run(): Promise<void> {
-    const { flags, args } = await this.parse(Apply)
+    const { flags, args } = await this.parse(Test)
 
     if (flags.path && args.pathArgs) {
       throw new Error('Cannot specify both --path and path argument');
     }
 
+    const hostSystem = os.platform() === 'darwin' ? OS.Darwin : OS.Linux;
+    const osFlag = flags.operatingSystem === 'macOS' ? OS.Darwin :
+      flags.operatingSystem === 'linux' ? OS.Linux : hostSystem;
+
     await TestOrchestrator.run({
       path: flags.path ?? args.pathArgs,
       verbosityLevel: flags.debug ? 3 : 0,
+      vmOs: osFlag,
       // secure: flags.secure,
     }, this.reporter);
 

src/common/initialize-plugins.ts

@@ -20,6 +20,7 @@ export interface InitializeArgs {
   allowEmptyProject?: boolean;
   forceEmptyProject?: boolean;
   codifyConfigs?: Config[];
+  noProgress?: boolean;
 }
 
 export interface InitializationResult {
@@ -38,10 +39,10 @@ export class PluginInitOrchestrator {
       reporter
     );
 
-    ctx.subprocessStarted(SubProcessName.INITIALIZE_PLUGINS)
+    if (!args.noProgress) ctx.subprocessStarted(SubProcessName.INITIALIZE_PLUGINS)
     const pluginManager = new PluginManager();
     const resourceDefinitions = await pluginManager.initialize(project, args.secure, args.verbosityLevel);
-    ctx.subprocessFinished(SubProcessName.INITIALIZE_PLUGINS)
+    if (!args.noProgress) ctx.subprocessFinished(SubProcessName.INITIALIZE_PLUGINS)
 
     return { resourceDefinitions, pluginManager, project };
   }

src/events/context.ts

@@ -21,6 +21,7 @@ export enum Event {
 }
 
 export enum ProcessName {
+  TEST = 'test',
   APPLY = 'apply',
   PLAN = 'plan',
   DESTROY = 'destroy',
@@ -39,6 +40,12 @@ export enum SubProcessName {
   VALIDATE = 'validate',
   GET_REQUIRED_PARAMETERS = 'get_required_parameters',
   IMPORT_RESOURCE = 'import_resource',
+  TEST_INITIALIZE_AND_VALIDATE = 'test_initialize_and_validate',
+  TEST_CHECKING_VM_INSTALLED = 'test_checking_vm_installed',
+  TEST_STARTING_VM = 'test_starting_vm',
+  TEST_COPYING_OVER_CONFIGS_AND_OPENING_TERMINAL = 'test_copying_over_configs_and_opening_terminal',
+  TEST_USER_CONTINUE_ON_VM = 'test_user_continue_on_vm',
+  TEST_DELETING_VM = 'test_deleting_vm',
 }
 
 export const ctx = new class {

src/orchestrators/apply.ts

@@ -7,11 +7,11 @@ export interface ApplyArgs {
   path?: string;
   secure?: boolean;
   verbosityLevel?: number;
+  noProgress?: boolean;
 }
 
 export const ApplyOrchestrator = {
   async run(args: ApplyArgs, reporter: Reporter): Promise<void> {
-
     const planResult = await PlanOrchestrator.run(args, reporter);
 
     // Short circuit and exit if every change is NOOP
@@ -28,9 +28,9 @@ export const ApplyOrchestrator = {
     const { plan, pluginManager, project } = planResult;
     const filteredPlan = plan.filterNoopResources()
 
-    ctx.processStarted(ProcessName.APPLY);
+    if (!args.noProgress) ctx.processStarted(ProcessName.APPLY);
     await pluginManager.apply(project, filteredPlan);
-    ctx.processFinished(ProcessName.APPLY);
+    if (!args.noProgress) ctx.processFinished(ProcessName.APPLY);
 
     reporter.displayMessage(`
 🎉 Finished applying 🎉

src/orchestrators/plan.ts

@@ -14,6 +14,7 @@ export interface PlanArgs {
   secureMode?: boolean;
   verbosityLevel?: number;
   codifyConfigs?: Config[];
+  noProgress?: boolean;
 }
 
 export interface PlanOrchestratorResponse {
@@ -24,7 +25,7 @@ export interface PlanOrchestratorResponse {
 
 export class PlanOrchestrator {
   static async run(args: PlanArgs, reporter: Reporter): Promise<PlanOrchestratorResponse> {
-    ctx.processStarted(ProcessName.PLAN);
+    if (!args.noProgress) ctx.processStarted(ProcessName.PLAN);
 
     const initializationResult = await PluginInitOrchestrator.run({
       ...args,
@@ -33,16 +34,17 @@ export class PlanOrchestrator {
 
     await createStartupShellScriptsIfNotExists();
 
-    await ValidateOrchestrator.run({ existing: initializationResult }, reporter);
+    await ValidateOrchestrator.run({ existing: initializationResult, noProgress: args.noProgress }, reporter);
     project.resolveDependenciesAndCalculateEvalOrder(resourceDefinitions);
     project.addXCodeToolsConfig(); // We have to add xcode-tools config always since almost every resource depends on it
 
-    const plan = await PlanOrchestrator.plan(project, pluginManager);
+    const plan = await PlanOrchestrator.plan(project, pluginManager, args.noProgress);
     plan.sortByEvalOrder(project.evaluationOrder);
     project.removeNoopFromEvaluationOrder(plan);
 
-    ctx.processFinished(ProcessName.PLAN)
+    if (!args.noProgress) ctx.processFinished(ProcessName.PLAN)
 
+    await reporter.hide();
     reporter.displayPlan(plan);
 
     return {
@@ -52,10 +54,10 @@ export class PlanOrchestrator {
     };
   }
 
-  private static async plan(project: Project, pluginManager: PluginManager): Promise<Plan> {
-    ctx.subprocessStarted(SubProcessName.GENERATE_PLAN)
+  private static async plan(project: Project, pluginManager: PluginManager, silent?: boolean): Promise<Plan> {
+    if (!silent) ctx.subprocessStarted(SubProcessName.GENERATE_PLAN)
     const plan = await pluginManager.plan(project);
-    ctx.subprocessFinished(SubProcessName.GENERATE_PLAN)
+    if (!silent) ctx.subprocessFinished(SubProcessName.GENERATE_PLAN)
 
     return plan;
   }

src/orchestrators/test.ts

@@ -1,74 +1,73 @@
 
-import { SpawnStatus } from 'codify-schemas';
+import { OS, SpawnStatus } from 'codify-schemas';
+import os from 'node:os';
 
 import { PluginInitOrchestrator } from '../common/initialize-plugins.js';
-import { ProcessName, ctx } from '../events/context.js';
+import { ProcessName, ctx, SubProcessName } from '../events/context.js';
 import { Reporter } from '../ui/reporters/reporter.js';
+import { StubReporter } from '../ui/reporters/stub-reporter.js';
 import { sleep } from '../utils/index.js';
 import { spawn, spawnSafe } from '../utils/spawn.js';
-import { PlanOrchestrator } from './plan.js';
+import { PlanOrchestrator, PlanOrchestratorResponse } from './plan.js';
 import { ValidateOrchestrator } from './validate.js';
 
 export interface TestArgs {
   path?: string;
   secure?: boolean;
   verbosityLevel?: number;
+  vmOs: OS;
 }
 
 export const TestOrchestrator = {
   async run(args: TestArgs, reporter: Reporter): Promise<void> {
-    
-    // Perform validation initially to ensure the project is valid
-    const initializationResult = await PluginInitOrchestrator.run(args, reporter);
-    await ValidateOrchestrator.run({ existing: initializationResult }, reporter);
-
-    const planResult = await PlanOrchestrator.run({
-      codifyConfigs: [{
-        type: 'project',
-        plugins: { default: '/Users/kevinwang/Projects/codify-homebrew-plugin/src/index.ts' }
-      }, {
-        type: 'homebrew',
-        formulae: ['sshpass']
-      }, {
-        type: 'tart',
-        clone: [{ sourceName: 'ghcr.io/cirruslabs/macos-tahoe-base:latest', name: 'codify-test-vm' }],
-      }],
-    }, reporter);
+    ctx.processStarted(ProcessName.TEST);
+    reporter.silent = true;
 
-    // Short circuit and exit if every change is NOOP
-    if (!planResult.plan.isEmpty()) {
-      const confirm = await reporter.promptConfirmation('The following resources will need to be installed (Tart VM - 25gb). Do you want to continue?')
-      if (!confirm) {
-        return process.exit(0);
-      }
-
-      const { plan, pluginManager, project } = planResult;
-      const filteredPlan = plan.filterNoopResources()
+    ctx.subprocessStarted(SubProcessName.TEST_INITIALIZE_AND_VALIDATE);
+    // Perform validation initially to ensure the project is valid
+    const initializationResult = await PluginInitOrchestrator.run({ ...args, noProgress: true }, new StubReporter());
+    await ValidateOrchestrator.run({ existing: initializationResult, noProgress: true }, new StubReporter());
+    ctx.subprocessFinished(SubProcessName.TEST_INITIALIZE_AND_VALIDATE);
 
-      ctx.processStarted(ProcessName.APPLY);
-      await pluginManager.apply(project, filteredPlan);
-      ctx.processFinished(ProcessName.APPLY);
-    }
+    await this.ensureVmIsInstalled(reporter, args.vmOs);
 
+    ctx.subprocessStarted(SubProcessName.TEST_STARTING_VM);
+    const baseVmName = args.vmOs === OS.Darwin ? 'codify-test-vm-macos' : 'codify-test-vm-linux';
     const vmName = this.generateVmName();
-    await spawnSafe(`tart clone codify-test-vm ${vmName}`, { interactive: true });
+    await spawnSafe(`tart clone ${baseVmName} ${vmName}`, { interactive: true });
 
     // Run this in the background. The user will have to manually exit the GUI to stop the test.
     spawnSafe(`tart run ${vmName}`, { interactive: true })
       .finally(() => {
+        ctx.subprocessFinished(SubProcessName.TEST_USER_CONTINUE_ON_VM);
+        ctx.subprocessStarted(SubProcessName.TEST_DELETING_VM);
+
+        spawnSafe(`tart delete ${vmName}`, { interactive: true })
+        ctx.subprocessFinished(SubProcessName.TEST_DELETING_VM);
+
+        ctx.processFinished(ProcessName.TEST);
         console.log('VM has been killed... exiting.')
         process.exit(1);
       })
     await sleep(10_000);
     await this.waitUntilVmIsReady(vmName);
 
+    ctx.subprocessFinished(SubProcessName.TEST_STARTING_VM);
+
+    ctx.subprocessStarted(SubProcessName.TEST_COPYING_OVER_CONFIGS_AND_OPENING_TERMINAL);
     // Install codify on the VM
     // await spawn(`tart exec ${vmName} /bin/bash -c "$(curl -fsSL https://releases.codifycli.com/install.sh)"`, { interactive: true });
     const { data: ip } = await spawnSafe(`tart ip ${vmName}`, { interactive: true });
     await spawn(`sshpass -p "admin" scp -o PubkeyAuthentication=no -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null ${initializationResult.project.codifyFiles[0]} admin@${ip}:~/codify.jsonc`, { interactive: true });
-    // await spawn(`tart exec ${vmName} codify apply`, undefined, { interactive: true });
 
-    await spawn(`tart exec ${vmName} osascript -e "tell application \\"Terminal\\" to do script \\"cd ~/ && codify apply\\""`)
+    if (args.vmOs === OS.Darwin) {
+      await spawn(`tart exec ${vmName} osascript -e "tell application \\"Terminal\\" to do script \\"cd ~/ && codify apply\\""`, { interactive: true });
+    } else {
+      await spawn(`tart exec ${vmName} gnome-terminal -- bash -c "cd ~/ && codify apply"`, { interactive: true });
+    }
+
+    ctx.subprocessFinished(SubProcessName.TEST_COPYING_OVER_CONFIGS_AND_OPENING_TERMINAL);
+    ctx.subprocessStarted(SubProcessName.TEST_USER_CONTINUE_ON_VM);
 
     await sleep(1_000_000_000);
   },
@@ -77,6 +76,57 @@ export const TestOrchestrator = {
     return `codify-test-vm-${Date.now()}`;
   },
 
+  async ensureVmIsInstalled(reporter: Reporter, vmOs: OS): Promise<void> {
+    if (vmOs === OS.Windows) {
+      throw new Error('VM installation not supported on Windows');
+    }
+
+    const hostSystem = os.platform() === 'darwin' ? OS.Darwin : OS.Linux;
+
+    let planResult: PlanOrchestratorResponse;
+    if (hostSystem === OS.Darwin) {
+      const vmImage = vmOs === OS.Darwin ? 'ghcr.io/cirruslabs/macos-tahoe-base:latest' : 'ghcr.io/cirruslabs/ubuntu-runner-arm64:latest';
+      const vmName = vmOs === OS.Darwin ? 'codify-test-vm-macos' : 'codify-test-vm-linux';
+
+      ctx.subprocessStarted(SubProcessName.TEST_CHECKING_VM_INSTALLED);
+      planResult = await PlanOrchestrator.run({
+        codifyConfigs: [{
+          type: 'project',
+          plugins: { default: '/Users/kevinwang/Projects/codify-homebrew-plugin/src/index.ts' }
+        }, {
+          type: 'homebrew',
+          formulae: ['sshpass']
+        }, {
+          type: 'tart',
+          clone: [{ sourceName: vmImage, name: vmName }],
+        }],
+        noProgress: true,
+        verbosityLevel: -1,
+      }, new StubReporter());
+
+      reporter.silent = false;
+      ctx.subprocessFinished(SubProcessName.TEST_CHECKING_VM_INSTALLED);
+    } else {
+      throw new Error('VM installation not supported on Linux just yet');
+    }
+
+    // Short circuit and exit if every change is NOOP
+    if (!planResult.plan.isEmpty()) {
+      reporter.displayPlan(planResult.plan);
+      const confirm = await reporter.promptConfirmation('The following resources will need to be installed (Tart VM - 25gb). Do you want to continue?')
+      if (!confirm) {
+        return process.exit(0);
+      }
+
+      const { plan, pluginManager, project } = planResult;
+      await pluginManager.setVerbosityLevel(3);
+      const filteredPlan = plan.filterNoopResources()
+
+      await reporter.displayProgress();
+      await pluginManager.apply(project, filteredPlan);
+    }
+  },
+
   async waitUntilVmIsReady(vmName: string): Promise<void> {
     while (true) {
       const result = await spawnSafe(`tart exec ${vmName} pwd`, { interactive: true, timeout: 5000 })

src/orchestrators/validate.ts

@@ -6,6 +6,7 @@ export interface ValidateArgs {
   existing?: InitializationResult;
   path?: string;
   verbosityLevel?: number;
+  noProgress?: boolean;
 }
 
 export const ValidateOrchestrator = {
@@ -20,20 +21,24 @@ export const ValidateOrchestrator = {
       pluginManager,
     } = args.existing ?? await PluginInitOrchestrator.run(args, reporter)
 
-    if (args.existing) {
-      ctx.subprocessStarted(SubProcessName.VALIDATE)
-    } else {
-      ctx.processStarted(SubProcessName.VALIDATE)
+    if (!args.noProgress) {
+      if (args.existing) {
+        ctx.subprocessStarted(SubProcessName.VALIDATE)
+      } else {
+        if (!args.noProgress) ctx.processStarted(SubProcessName.VALIDATE)
+      }
     }
 
     project.validateTypeIds(resourceDefinitions);
     const validationResults = await pluginManager.validate(project);
     project.handlePluginResourceValidationResults(validationResults);
 
-    if (args.existing) {
-      ctx.subprocessFinished(SubProcessName.VALIDATE)
-    } else {
-      ctx.processFinished(SubProcessName.VALIDATE)
+    if (!args.noProgress) {
+      if (args.existing) {
+        ctx.subprocessFinished(SubProcessName.VALIDATE)
+      } else {
+        ctx.processFinished(SubProcessName.VALIDATE)
+      }
     }
   },
 };

src/plugins/plugin-manager.ts

@@ -152,6 +152,12 @@ export class PluginManager {
     }
   }
 
+  async setVerbosityLevel(verbosityLevel: number): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      await plugin.setVerbosityLevel(verbosityLevel);
+    }
+  }
+
   private async resolvePlugins(project: Project | null): Promise<Plugin[]> {
     const pluginDefinitions: Record<string, string> = {
       ...DEFAULT_PLUGINS,