maestro: accept multiple flow paths

Author: jochen-testingbot

src/cli.ts

@@ -204,18 +204,14 @@ const maestroCommand = program
     'Path to application under test (.apk, .ipa, .app or .zip)',
   )
   .argument(
-    '[flows]',
-    'Path to flow file (.yaml/.yml), directory, .zip or glob pattern',
+    '[flows...]',
+    'Paths to flow files, directories, or glob patterns (can specify multiple)',
   )
   // App and flows options
   .option(
     '--app <path>',
     'Path to application under test (.apk, .ipa, .app, or .zip).',
   )
-  .option(
-    '--flows <path>',
-    'Path to flow file (.yaml/.yml), directory of flows, .zip file or glob pattern.',
-  )
   // Device configuration
   .option(
     '--device <device>',
@@ -299,13 +295,24 @@ const maestroCommand = program
   // Authentication
   .option('--api-key <key>', 'TestingBot API key.')
   .option('--api-secret <secret>', 'TestingBot API secret.')
-  .action(async (appFileArg, flowsArg, args) => {
+  .action(async (appFileArg, flowsArgs, args) => {
     try {
-      // Positional arguments take precedence, fall back to options
-      const app = appFileArg || args.app;
-      const flows = flowsArg || args.flows;
+      let app: string;
+      let flows: string[];
+
+      if (args.app) {
+        // If --app is specified, treat all positional arguments as flows
+        app = args.app;
+        flows = appFileArg
+          ? [appFileArg, ...(flowsArgs || [])]
+          : flowsArgs || [];
+      } else {
+        // Otherwise, first positional is app, rest are flows
+        app = appFileArg;
+        flows = flowsArgs || [];
+      }
 
-      if (!app || !flows) {
+      if (!app || flows.length === 0) {
         maestroCommand.help();
         return;
       }

src/models/maestro_options.ts

@@ -32,7 +32,7 @@ export interface MaestroRunOptions {
 
 export default class MaestroOptions {
   private _app: string;
-  private _flows: string;
+  private _flows: string[];
   private _device?: string;
   private _includeTags?: string[];
   private _excludeTags?: string[];
@@ -55,7 +55,7 @@ export default class MaestroOptions {
 
   public constructor(
     app: string,
-    flows: string,
+    flows: string | string[],
     device?: string,
     options?: {
       includeTags?: string[];
@@ -79,7 +79,7 @@ export default class MaestroOptions {
     },
   ) {
     this._app = app;
-    this._flows = flows;
+    this._flows = flows ? (Array.isArray(flows) ? flows : [flows]) : [];
     this._device = device;
     this._includeTags = options?.includeTags;
     this._excludeTags = options?.excludeTags;
@@ -105,7 +105,7 @@ export default class MaestroOptions {
     return this._app;
   }
 
-  public get flows(): string {
+  public get flows(): string[] {
     return this._flows;
   }
 

src/providers/maestro.ts

@@ -80,22 +80,23 @@ export default class Maestro {
       );
     }
 
-    if (this.options.flows === undefined) {
+    if (this.options.flows === undefined || this.options.flows.length === 0) {
       throw new TestingBotError(`flows option is required`);
     }
 
-    // Check if flows path exists (can be a file, directory, or glob pattern)
-    const flowsPath = this.options.flows;
-    const isGlobPattern =
-      flowsPath.includes('*') ||
-      flowsPath.includes('?') ||
-      flowsPath.includes('{');
+    // Check if all flows paths exist (can be files, directories, or glob patterns)
+    for (const flowsPath of this.options.flows) {
+      const isGlobPattern =
+        flowsPath.includes('*') ||
+        flowsPath.includes('?') ||
+        flowsPath.includes('{');
 
-    if (!isGlobPattern) {
-      try {
-        await fs.promises.access(flowsPath, fs.constants.R_OK);
-      } catch {
-        throw new TestingBotError(`flows path does not exist ${flowsPath}`);
+      if (!isGlobPattern) {
+        try {
+          await fs.promises.access(flowsPath, fs.constants.R_OK);
+        } catch {
+          throw new TestingBotError(`flows path does not exist ${flowsPath}`);
+        }
       }
     }
 
@@ -251,52 +252,87 @@ export default class Maestro {
   }
 
   private async uploadFlows() {
-    const flowsPath = this.options.flows;
-    const stat = await fs.promises.stat(flowsPath).catch(() => null);
+    const flowsPaths = this.options.flows;
 
     let zipPath: string;
     let shouldCleanup = false;
 
-    if (stat?.isFile()) {
-      const ext = path.extname(flowsPath).toLowerCase();
-      if (ext === '.zip') {
-        // Already a zip file, upload directly
-        zipPath = flowsPath;
-      } else if (ext === '.yaml' || ext === '.yml') {
-        // Single flow file, create a zip
-        zipPath = await this.createFlowsZip([flowsPath]);
-        shouldCleanup = true;
-      } else {
-        throw new TestingBotError(
-          `Invalid flow file format. Expected .yaml, .yml, or .zip, got ${ext}`,
-        );
-      }
-    } else if (stat?.isDirectory()) {
-      // Directory of flows
-      const flowFiles = await this.discoverFlows(flowsPath);
-      if (flowFiles.length === 0) {
-        throw new TestingBotError(
-          `No flow files (.yaml, .yml) found in directory ${flowsPath}`,
-        );
+    // Special case: single zip file - upload directly
+    if (flowsPaths.length === 1) {
+      const singlePath = flowsPaths[0];
+      const stat = await fs.promises.stat(singlePath).catch(() => null);
+      if (stat?.isFile() && path.extname(singlePath).toLowerCase() === '.zip') {
+        zipPath = singlePath;
+        // Upload the zip directly without cleanup
+        await this.upload.upload({
+          filePath: zipPath,
+          url: `${this.URL}/${this.appId}/tests`,
+          credentials: this.credentials,
+          contentType: 'application/zip',
+          showProgress: !this.options.quiet,
+        });
+        return true;
       }
-      zipPath = await this.createFlowsZip(flowFiles, flowsPath);
-      shouldCleanup = true;
-    } else {
-      // Treat as glob pattern
-      const flowFiles = await glob(flowsPath);
-      const yamlFiles = flowFiles.filter((f) => {
-        const ext = path.extname(f).toLowerCase();
-        return ext === '.yaml' || ext === '.yml';
-      });
-      if (yamlFiles.length === 0) {
-        throw new TestingBotError(
-          `No flow files found matching pattern ${flowsPath}`,
-        );
+    }
+
+    // Collect all flow files from all paths
+    const allFlowFiles: string[] = [];
+    const baseDirs: string[] = [];
+
+    for (const flowsPath of flowsPaths) {
+      const stat = await fs.promises.stat(flowsPath).catch(() => null);
+
+      if (stat?.isFile()) {
+        const ext = path.extname(flowsPath).toLowerCase();
+        if (ext === '.yaml' || ext === '.yml') {
+          allFlowFiles.push(flowsPath);
+        } else if (ext === '.zip') {
+          throw new TestingBotError(
+            `Cannot combine .zip files with other flow paths. Use a single .zip file or provide directories/patterns.`,
+          );
+        } else {
+          throw new TestingBotError(
+            `Invalid flow file format. Expected .yaml, .yml, or .zip, got ${ext}`,
+          );
+        }
+      } else if (stat?.isDirectory()) {
+        // Directory of flows
+        const flowFiles = await this.discoverFlows(flowsPath);
+        if (flowFiles.length === 0 && flowsPaths.length === 1) {
+          throw new TestingBotError(
+            `No flow files (.yaml, .yml) found in directory ${flowsPath}`,
+          );
+        }
+        allFlowFiles.push(...flowFiles);
+        baseDirs.push(flowsPath);
+      } else {
+        // Treat as glob pattern
+        const flowFiles = await glob(flowsPath);
+        const yamlFiles = flowFiles.filter((f) => {
+          const ext = path.extname(f).toLowerCase();
+          return ext === '.yaml' || ext === '.yml';
+        });
+        if (yamlFiles.length === 0 && flowsPaths.length === 1) {
+          throw new TestingBotError(
+            `No flow files found matching pattern ${flowsPath}`,
+          );
+        }
+        allFlowFiles.push(...yamlFiles);
       }
-      zipPath = await this.createFlowsZip(yamlFiles);
-      shouldCleanup = true;
     }
 
+    if (allFlowFiles.length === 0) {
+      throw new TestingBotError(
+        `No flow files (.yaml, .yml) found in the provided paths`,
+      );
+    }
+
+    // Determine base directory for zip structure
+    // If we have a single directory, use it as base; otherwise use common ancestor or flatten
+    const baseDir = baseDirs.length === 1 ? baseDirs[0] : undefined;
+    zipPath = await this.createFlowsZip(allFlowFiles, baseDir);
+    shouldCleanup = true;
+
     try {
       await this.upload.upload({
         filePath: zipPath,

tests/cli.test.ts

@@ -200,13 +200,30 @@ describe('TestingBotCTL CLI', () => {
       'app.apk',
       '--device',
       'device-1',
-      '--flows',
       './flows',
     ]);
 
     expect(mockMaestroRun).toHaveBeenCalledTimes(1);
   });
 
+  test('maestro command should accept multiple flow paths', async () => {
+    mockGetCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+
+    await program.parseAsync([
+      'node',
+      'cli',
+      'maestro',
+      'app.apk',
+      './flows1',
+      './flows2',
+      './flows3',
+      '--device',
+      'device-1',
+    ]);
+
+    expect(mockMaestroRun).toHaveBeenCalledTimes(1);
+  });
+
   test('maestro command should accept include-tags and exclude-tags', async () => {
     mockGetCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
 

tests/models/maestro_options.test.ts

@@ -6,7 +6,7 @@ describe('MaestroOptions', () => {
       const options = new MaestroOptions('app.apk', './flows', 'Pixel 8');
 
       expect(options.app).toBe('app.apk');
-      expect(options.flows).toBe('./flows');
+      expect(options.flows).toEqual(['./flows']);
       expect(options.device).toBe('Pixel 8');
       expect(options.platformName).toBeUndefined();
       expect(options.version).toBeUndefined();
@@ -43,7 +43,7 @@ describe('MaestroOptions', () => {
       });
 
       expect(options.app).toBe('app.apk');
-      expect(options.flows).toBe('./flows');
+      expect(options.flows).toEqual(['./flows']);
       expect(options.device).toBe('Pixel 8');
       expect(options.includeTags).toEqual(['smoke']);
       expect(options.excludeTags).toEqual(['flaky']);
@@ -72,6 +72,23 @@ describe('MaestroOptions', () => {
 
       expect(options.async).toBe(false);
     });
+
+    it('should accept multiple flow paths as an array', () => {
+      const options = new MaestroOptions(
+        'app.apk',
+        ['./flows1', './flows2', './flows3'],
+        'Pixel 8',
+      );
+
+      expect(options.flows).toEqual(['./flows1', './flows2', './flows3']);
+    });
+
+    it('should normalize single flow path to an array', () => {
+      const options = new MaestroOptions('app.apk', './flows', 'Pixel 8');
+
+      expect(options.flows).toEqual(['./flows']);
+      expect(Array.isArray(options.flows)).toBe(true);
+    });
   });
 
   describe('getCapabilities', () => {