@devicecloud.dev/dcd 5.3.0 → 5.3.1-beta.1

package/dist/services/execution-plan.service.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { getFlowsToRunInSequence, isFlowFile, processDependencies, readDirectory, readTestYamlFileAsJson, readYamlFileAsJson, } from './execution-plan.utils.js';
+import { getFlowsToRunInSequence, isFlowFile, isWorkspaceConfigFile, processDependencies, readDirectory, readTestYamlFileAsJson, readYamlFileAsJson, } from './execution-plan.utils.js';
 /**
  * Recursively check and resolve all dependencies for a flow file
  * Includes runFlow references, JavaScript scripts, and media files
@@ -88,12 +88,14 @@ function extractDeviceCloudOverrides(config) {
 /**
  * Generate execution plan for a single flow file
  * @param normalizedInput - Normalized path to the flow file
- * @param configFile - Optional custom config file path
+ * @param resolvedConfigFile - Optional absolute path to a custom config file
  * @returns Execution plan for the single file with dependencies
  */
-async function planSingleFile(normalizedInput, configFile) {
-    if (normalizedInput.endsWith('config.yaml') ||
-        normalizedInput.endsWith('config.yml')) {
+async function planSingleFile(normalizedInput, resolvedConfigFile) {
+    const inputBasename = path.basename(normalizedInput);
+    if (inputBasename === 'config.yaml' ||
+        inputBasename === 'config.yml' ||
+        isWorkspaceConfigFile(normalizedInput)) {
         throw new Error('If using config.yaml, pass the workspace folder path, not the config file or a custom path via --config');
     }
     const { config } = readTestYamlFileAsJson(normalizedInput);
@@ -104,12 +106,11 @@ async function planSingleFile(normalizedInput, configFile) {
         flowOverrides[normalizedInput] = extractDeviceCloudOverrides(config);
     }
     let workspaceConfig;
-    if (configFile) {
-        const configFilePath = path.resolve(process.cwd(), configFile);
-        if (!fs.existsSync(configFilePath)) {
-            throw new Error(`Config file does not exist: ${configFilePath}`);
+    if (resolvedConfigFile) {
+        if (!fs.existsSync(resolvedConfigFile)) {
+            throw new Error(`Config file does not exist: ${resolvedConfigFile}`);
         }
-        workspaceConfig = readYamlFileAsJson(configFilePath);
+        workspaceConfig = readYamlFileAsJson(resolvedConfigFile);
     }
     const checkedDependancies = await checkDependencies(normalizedInput);
     return {
@@ -126,11 +127,24 @@ async function planSingleFile(normalizedInput, configFile) {
  * @param workspaceConfig - Workspace configuration containing flow globs
  * @param normalizedInput - Normalized path to the workspace directory
  * @param unfilteredFlowFiles - List of all discovered flow files
- * @param configFile - Optional custom config file path
+ * @param resolvedConfigFile - Optional absolute path to a custom config file
  * @param excludeFlows - --exclude-flows patterns to re-apply to glob matches
  * @returns Filtered list of flow file paths matching the globs
  */
-async function applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFiles, configFile, excludeFlows) {
+async function applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFiles, resolvedConfigFile, excludeFlows) {
+    // Both branches compare absolute paths, so `--config ./x.yml` and
+    // `--config /abs/x.yml` behave identically, and a same-named file in a
+    // sibling directory is never mistaken for the active config.
+    const activeConfig = resolvedConfigFile
+        ? path.normalize(resolvedConfigFile)
+        : undefined;
+    const isExcludedConfig = (absolutePath) => {
+        const base = path.basename(absolutePath);
+        if (base === 'config.yaml' || base === 'config.yml')
+            return true;
+        return (activeConfig !== undefined &&
+            path.normalize(absolutePath) === activeConfig);
+    };
     if (workspaceConfig.flows) {
         const globs = workspaceConfig.flows.map((g) => g);
         // fs.globSync lands in Node 22; the CLI's `engines.node` already requires it.
@@ -144,29 +158,17 @@ async function applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFi
                 return false;
             }
         });
+        // Resolve before filtering: glob matches are relative to normalizedInput,
+        // so comparing them against the config path only ever worked when the
+        // config happened to sit at the workspace root.
         const globbedFlowFiles = matchedFiles
-            .filter((file) => {
-            if (file === 'config.yaml' || file === 'config.yml')
-                return false;
-            if (configFile && file === path.basename(configFile))
-                return false;
-            if (!file.endsWith('.yaml') && !file.endsWith('.yml'))
-                return false;
-            const pathParts = file.split(path.sep);
-            for (const part of pathParts) {
-                if (part.endsWith('.app'))
-                    return false;
-            }
-            return true;
-        })
-            .map((file) => path.resolve(normalizedInput, file));
+            .map((file) => path.resolve(normalizedInput, file))
+            .filter((file) => !isExcludedConfig(file) && isFlowFile(file));
         // Re-globbing from disk bypasses the earlier --exclude-flows filter, so
         // re-apply it here or excluded flows sneak back in via `flows:` globs.
         return filterFlowFiles(globbedFlowFiles, excludeFlows);
     }
-    return unfilteredFlowFiles.filter((file) => !file.endsWith('config.yaml') &&
-        !file.endsWith('config.yml') &&
-        (!configFile || !file.endsWith(configFile)));
+    return unfilteredFlowFiles.filter((file) => !isExcludedConfig(file));
 }
 /**
  * Resolve sequential execution order from workspace config
@@ -226,11 +228,14 @@ export async function plan(options) {
     const { input, includeTags = [], excludeTags = [], excludeFlows, configFile, debug = false, } = options;
     const normalizedInput = path.normalize(input);
     const flowMetadata = {};
+    const resolvedConfigFile = configFile
+        ? path.resolve(process.cwd(), configFile)
+        : undefined;
     if (!fs.existsSync(normalizedInput)) {
         throw new Error(`Flow path does not exist: ${path.resolve(normalizedInput)}`);
     }
     if (fs.lstatSync(normalizedInput).isFile()) {
-        return planSingleFile(normalizedInput, configFile);
+        return planSingleFile(normalizedInput, resolvedConfigFile);
     }
     let unfilteredFlowFiles = await readDirectory(normalizedInput, isFlowFile);
     if (unfilteredFlowFiles.length === 0) {
@@ -238,17 +243,30 @@ export async function plan(options) {
     }
     unfilteredFlowFiles = filterFlowFiles(unfilteredFlowFiles, excludeFlows);
     let workspaceConfig;
-    if (configFile) {
-        const configFilePath = path.resolve(process.cwd(), configFile);
-        if (!fs.existsSync(configFilePath)) {
-            throw new Error(`Config file does not exist: ${configFilePath}`);
+    if (resolvedConfigFile) {
+        if (!fs.existsSync(resolvedConfigFile)) {
+            throw new Error(`Config file does not exist: ${resolvedConfigFile}`);
         }
-        workspaceConfig = readYamlFileAsJson(configFilePath);
+        workspaceConfig = readYamlFileAsJson(resolvedConfigFile);
     }
     else {
         workspaceConfig = getWorkspaceConfig(normalizedInput, unfilteredFlowFiles);
     }
-    unfilteredFlowFiles = await applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFiles, configFile, excludeFlows);
+    unfilteredFlowFiles = await applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFiles, resolvedConfigFile, excludeFlows);
+    // The exclusions above are filename-based: they only catch
+    // `config.yaml`/`config.yml` and the active --config target. Any other
+    // workspace config sharing the folder (a second CI workflow's, say) is still
+    // on the list and would be parsed as a flow, so drop config-shaped files by
+    // shape — see dcd-cli#99.
+    const configShapedFiles = new Set(unfilteredFlowFiles.filter((file) => isWorkspaceConfigFile(file)));
+    if (configShapedFiles.size > 0) {
+        if (debug) {
+            console.log(`[DEBUG] Skipping ${configShapedFiles.size} workspace config file(s): ${[
+                ...configShapedFiles,
+            ].join(', ')}`);
+        }
+        unfilteredFlowFiles = unfilteredFlowFiles.filter((file) => !configShapedFiles.has(file));
+    }
     if (unfilteredFlowFiles.length === 0) {
         const error = workspaceConfig.flows
             ? new Error(`Flow inclusion pattern(s) did not match any Flow files:\n${workspaceConfig.flows.join('\n')}`)

package/dist/services/execution-plan.utils.d.ts

@@ -2,6 +2,21 @@ export declare function getFlowsToRunInSequence(paths: {
     [key: string]: string;
 }, flowOrder: string[], debug?: boolean): string[];
 export declare function isFlowFile(filePath: string): boolean;
+/**
+ * True when a YAML file is a workspace config rather than a runnable flow.
+ *
+ * A flow is either `front matter --- steps` or a bare steps array; a
+ * single-document top-level map carrying workspace-config keys is neither, and
+ * left in the flow list it blows up processDependencies with "Expected an array
+ * of steps". Detection is by shape, not filename, so several named configs can
+ * coexist in one folder (dcd-cli#99). Requiring a recognised config key — not
+ * just "single document, top-level map" — keeps a flow that is merely *missing*
+ * its `---` separator loud rather than silently dropped.
+ *
+ * @param filePath - Path to the YAML file to classify
+ * @returns Whether the file is a workspace config rather than a flow
+ */
+export declare function isWorkspaceConfigFile(filePath: string): boolean;
 export declare const readYamlFileAsJson: (filePath: string) => unknown;
 export declare const readTestYamlFileAsJson: (filePath: string) => {
     config: Record<string, unknown>;

package/dist/services/execution-plan.utils.js

@@ -38,6 +38,53 @@ export function isFlowFile(filePath) {
     }
     return filePath.endsWith('.yaml') || filePath.endsWith('.yml');
 }
+/**
+ * Top-level keys that only ever appear in a workspace config (see
+ * IWorkspaceConfig in execution-plan.service.ts). Deliberately excludes keys
+ * Maestro also allows in flow front matter — appId, name, tags, env,
+ * onFlowStart, onFlowComplete, jsEngine.
+ */
+const WORKSPACE_CONFIG_KEYS = new Set([
+    'excludeTags',
+    'executionOrder',
+    'flows',
+    'includeTags',
+    'local',
+    'notifications',
+    'platform',
+]);
+/**
+ * True when a YAML file is a workspace config rather than a runnable flow.
+ *
+ * A flow is either `front matter --- steps` or a bare steps array; a
+ * single-document top-level map carrying workspace-config keys is neither, and
+ * left in the flow list it blows up processDependencies with "Expected an array
+ * of steps". Detection is by shape, not filename, so several named configs can
+ * coexist in one folder (dcd-cli#99). Requiring a recognised config key — not
+ * just "single document, top-level map" — keeps a flow that is merely *missing*
+ * its `---` separator loud rather than silently dropped.
+ *
+ * @param filePath - Path to the YAML file to classify
+ * @returns Whether the file is a workspace config rather than a flow
+ */
+export function isWorkspaceConfigFile(filePath) {
+    let parsed;
+    try {
+        parsed = readTestYamlFileAsJson(filePath);
+    }
+    catch {
+        // Unparseable — leave it in the flow list so the existing error path reports it.
+        return false;
+    }
+    const { config, testSteps } = parsed;
+    if (config !== null)
+        return false; // has `---` front matter → flow
+    if (Array.isArray(testSteps))
+        return false; // bare steps array → flow
+    if (!testSteps || typeof testSteps !== 'object')
+        return false;
+    return Object.keys(testSteps).some((key) => WORKSPACE_CONFIG_KEYS.has(key));
+}
 export const readYamlFileAsJson = (filePath) => {
     try {
         const normalizedPath = path.normalize(filePath);

package/package.json

@@ -31,7 +31,7 @@
     "chai": "^6.2.2",
     "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-unicorn": "^72.0.0",
+    "eslint-plugin-unicorn": "^73.0.0",
     "husky": "^9.1.7",
     "mocha": "^11.7.6",
     "prettier": "^3.8.4",
@@ -59,7 +59,7 @@
     "type": "git",
     "url": "https://devicecloud.dev"
   },
-  "version": "5.3.0",
+  "version": "5.3.1-beta.1",
   "bugs": {
     "url": "https://discord.gg/gm3mJwcNw8"
   },