feat: Added codify test command that can spawn a tart vm to test codify configs

Author: kevinwang5658

src/commands/test.ts

@@ -0,0 +1,62 @@
+import { Args, Flags } from '@oclif/core'
+import chalk from 'chalk';
+
+import { BaseCommand } from '../common/base-command.js';
+import { ApplyOrchestrator } from '../orchestrators/apply.js';
+import { TestOrchestrator } from '../orchestrators/test.js';
+
+export default class Apply extends BaseCommand {
+  static description =
+`Install or update resources on the system based on a codify.jsonc file.
+
+Codify first generates a plan to determine the necessary execution steps. See
+${chalk.bold.bgMagenta(' codify plan --help ')} for more details.
+The execution plan will be presented and approval will be asked before Codify applies
+any changes.
+
+For scripts: use ${chalk.bold.bgMagenta(' --output json ')} which will skip approval and 
+apply changes directly.
+
+For more information, visit: https://docs.codifycli.com/commands/apply
+`
+
+  static flags = {
+    'sudoPassword': Flags.string({
+      optional: true,
+      description: 'Automatically use this password for any handlers that require elevated permissions.',
+      char: 'S'
+    }),
+  }
+
+  static args = {
+    pathArgs: Args.string(),
+  }
+
+  static examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --path ~',
+    '<%= config.bin %> <%= command.id %> -o json',
+    '<%= config.bin %> <%= command.id %> -S <sudo password>',
+  ]
+
+  async init(): Promise<void> {
+    console.log('Running Codify apply...')
+    return super.init();
+  }
+
+  public async run(): Promise<void> {
+    const { flags, args } = await this.parse(Apply)
+
+    if (flags.path && args.pathArgs) {
+      throw new Error('Cannot specify both --path and path argument');
+    }
+
+    await TestOrchestrator.run({
+      path: flags.path ?? args.pathArgs,
+      verbosityLevel: flags.debug ? 3 : 0,
+      // secure: flags.secure,
+    }, this.reporter);
+
+    process.exit(0);
+  }
+}

src/common/base-command.ts

@@ -67,7 +67,7 @@ export abstract class BaseCommand extends Command {
           process.stdin.setRawMode(true);
         }
 
-        const result = await spawnSafe(data.command, pluginName, data.options, password)
+        const result = await spawnSafe(data.command, data.options, pluginName, password)
         ctx.commandRequestCompleted(pluginName, result);
 
         // This listener is outside of the base-command callstack. We have to manually catch the error.

src/common/errors.ts

@@ -156,6 +156,24 @@ export class UnauthorizedError extends CodifyError {
   }
 }
 
+export class SpawnError extends CodifyError {
+  name = 'SpawnError'
+  command: string;
+  exitCode: number;
+  data: string;
+
+  constructor(command: string, exitCode: number, data: string) {
+    super(`Command "${command}" failed with exit code ${exitCode}`)
+    this.command = command;
+    this.exitCode = exitCode;
+    this.data = data;
+  }
+
+  formattedMessage(): string {
+    return `Spawn error: ${this.message}\n\n${this.data}`
+  }
+}
+
 export function prettyPrintError(error: unknown): void {
   if (error instanceof CodifyError) {
     return console.error(chalk.red(error.formattedMessage()));

src/common/initialize-plugins.ts

@@ -1,3 +1,4 @@
+import { Config } from 'codify-schemas';
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 import { validate } from 'uuid';
@@ -18,6 +19,7 @@ export interface InitializeArgs {
   transformProject?: (project: Project) => Project | Promise<Project>;
   allowEmptyProject?: boolean;
   forceEmptyProject?: boolean;
+  codifyConfigs?: Config[];
 }
 
 export interface InitializationResult {
@@ -52,6 +54,10 @@ export class PluginInitOrchestrator {
       return Project.empty();
     }
 
+    if (args.codifyConfigs) {
+      return CodifyParser.parseJson(args.codifyConfigs);
+    }
+
     const codifyPath = await PluginInitOrchestrator.resolveCodifyRootPath(args, reporter);
     ctx.subprocessStarted(SubProcessName.PARSE);
 

src/orchestrators/plan.ts

@@ -1,3 +1,5 @@
+import { Config } from 'codify-schemas';
+
 import { PluginInitOrchestrator } from '../common/initialize-plugins.js';
 import { Plan } from '../entities/plan.js';
 import { Project } from '../entities/project.js';
@@ -6,12 +8,12 @@ import { PluginManager } from '../plugins/plugin-manager.js';
 import { Reporter } from '../ui/reporters/reporter.js';
 import { createStartupShellScriptsIfNotExists } from '../utils/file.js';
 import { ValidateOrchestrator } from './validate.js';
-import { LoginHelper } from '../connect/login-helper.js';
 
 export interface PlanArgs {
   path?: string;
   secureMode?: boolean;
   verbosityLevel?: number;
+  codifyConfigs?: Config[];
 }
 
 export interface PlanOrchestratorResponse {

src/orchestrators/test.ts

@@ -0,0 +1,90 @@
+
+import { SpawnStatus } from 'codify-schemas';
+
+import { PluginInitOrchestrator } from '../common/initialize-plugins.js';
+import { ProcessName, ctx } from '../events/context.js';
+import { Reporter } from '../ui/reporters/reporter.js';
+import { sleep } from '../utils/index.js';
+import { spawn, spawnSafe } from '../utils/spawn.js';
+import { PlanOrchestrator } from './plan.js';
+import { ValidateOrchestrator } from './validate.js';
+
+export interface TestArgs {
+  path?: string;
+  secure?: boolean;
+  verbosityLevel?: number;
+}
+
+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);
+
+    // 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.processStarted(ProcessName.APPLY);
+      await pluginManager.apply(project, filteredPlan);
+      ctx.processFinished(ProcessName.APPLY);
+    }
+
+    const vmName = this.generateVmName();
+    await spawnSafe(`tart clone codify-test-vm ${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(() => {
+        console.log('VM has been killed... exiting.')
+        process.exit(1);
+      })
+    await sleep(10_000);
+    await this.waitUntilVmIsReady(vmName);
+
+    // 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\\""`)
+
+    await sleep(1_000_000_000);
+  },
+
+  generateVmName(): string {
+    return `codify-test-vm-${Date.now()}`;
+  },
+
+  async waitUntilVmIsReady(vmName: string): Promise<void> {
+    while (true) {
+      const result = await spawnSafe(`tart exec ${vmName} pwd`, { interactive: true, timeout: 5000 })
+      if (result.status === SpawnStatus.SUCCESS) {
+        return;
+      }
+
+      await sleep(1000);
+    }
+  }
+};

src/parser/index.ts

@@ -1,3 +1,4 @@
+import { Config } from 'codify-schemas';
 import * as fs from 'node:fs/promises';
 import path from 'node:path';
 import { validate } from 'uuid'
@@ -39,6 +40,17 @@ class Parser {
     return Project.create(configs, codifyFiles, sourceMaps);
   }
 
+  async parseJson(configs: Config[]): Promise<Project> {
+    const sourceMaps = new SourceMapCache()
+
+    const configBlocks = this.createConfigBlocks(configs
+        .map((c) => ({ contents: c, sourceMapKey: '' })),
+      sourceMaps
+    )
+
+    return Project.create(configBlocks, [], sourceMaps);
+  }
+
   private async getFilePaths(dirOrFile: string): Promise<string[]> {
     // A cloud file is represented as an uuid. Skip file checks if it's a cloud file;
     if (validate(dirOrFile)) {

src/parser/source-maps.ts

@@ -1,8 +1,8 @@
+import chalk from 'chalk';
+import { default as YamlSourceMap } from 'js-yaml-source-map';
 import { JsonSourceMap } from 'json-source-map';
-import { default as YamlSourceMap, SourceLocation as YamlSourceLocation } from 'js-yaml-source-map';
+
 import { FileType, InMemoryFile } from './entities.js';
-import { InternalError } from '../common/errors.js';
-import chalk from 'chalk';
 import { JsonSourceMapAdapter } from './json/source-map.js';
 import { YamlSourceMapAdapter } from './yaml/source-map.js';
 
@@ -81,7 +81,7 @@ export class SourceMapCache {
     sourceMapKey: string,
     addAdditionalContextLines = true,
     addLineNumbers = true,
-  ): string | null {
+  ): null | string {
     const inContextSourceMap = this.getSourceMap(sourceMapKey);
     if (!inContextSourceMap) {
       return null;

src/ui/reporters/reporter.ts

@@ -9,6 +9,7 @@ import { DebugReporter } from './debug-reporter.js';
 import { DefaultReporter } from './default-reporter.js';
 import { JsonReporter } from './json-reporter.js';
 import { PlainReporter } from './plain-reporter.js';
+import { StubReporter } from './stub-reporter.js';
 
 export enum RenderEvent {
   LOG = 'log',

src/utils/spawn.ts

@@ -2,6 +2,7 @@ import * as pty from '@homebridge/node-pty-prebuilt-multiarch';
 import { SpawnStatus } from 'codify-schemas';
 import stripAnsi from 'strip-ansi';
 
+import { SpawnError } from '../common/errors.js';
 import { ctx } from '../events/context.js';
 import { Shell, ShellUtils } from './shell.js';
 
@@ -17,9 +18,20 @@ export interface SpawnOptions {
   interactive?: boolean,
   requiresRoot?: boolean,
   stdin?: boolean,
+  timeout?: number,
 }
 
-export function spawnSafe(cmd: string, pluginName?: string, options?: SpawnOptions, password?: string): Promise<SpawnResult> {
+export async function spawn(cmd: string, options?: SpawnOptions, pluginName?: string, password?: string): Promise<SpawnResult> {
+  const spawnResult = await spawnSafe(cmd, options, pluginName, password);
+
+  if (spawnResult.status !== 'success') {
+    throw new SpawnError(Array.isArray(cmd) ? cmd.join('\n') : cmd, spawnResult.exitCode, spawnResult.data);
+  }
+
+  return spawnResult;
+}
+
+export async function spawnSafe(cmd: string, options?: SpawnOptions, pluginName?: string, password?: string): Promise<SpawnResult> {
   if (options?.requiresRoot && !password) {
     throw new Error('Password must be specified!');
   }
@@ -31,7 +43,7 @@ export function spawnSafe(cmd: string, pluginName?: string, options?: SpawnOptio
   if (pluginName) {
     ctx.pluginStdout(pluginName, `Running command: ${options?.requiresRoot ? 'sudo' : ''} ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''))
   } else {
-    process.stdout.write(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''));
+    ctx.log(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : '') + '\n');
   }
 
   return new Promise((resolve) => {
@@ -67,7 +79,7 @@ export function spawnSafe(cmd: string, pluginName?: string, options?: SpawnOptio
       if (pluginName && !options?.stdin) {
         ctx.pluginStdout(pluginName, data)
       } else {
-        process.stdout.write(data);
+        ctx.log(data);
       }
 
       output.push(data.toString());
@@ -100,6 +112,17 @@ export function spawnSafe(cmd: string, pluginName?: string, options?: SpawnOptio
         exitCode: result.exitCode,
         data: stripAnsi(output.join('\n').trim()),
       })
-    })
+    });
+
+    if (options?.timeout) {
+      setTimeout(() => {
+        mPty.kill();
+        resolve({
+          status: SpawnStatus.ERROR,
+          exitCode: -1,
+          data: '',
+        });
+      }, options.timeout);
+    }
   })
 }