@copado/agentia-cli 0.122.0-alpha.0 → 1.0.0-beta.0

package/dist/lib/testing-flags.js

@@ -1,312 +1,14 @@
-import { Flags } from '@oclif/core';
-import { TESTING_CONSOLE_COLORS, TESTING_RECORD_BUILD_OPTIONS, TESTING_RUN_TYPES, } from './testing-types.js';
-export const testingProjectFlag = {
-    project: Flags.integer({
-        char: 'p',
-        description: 'CRT project ID.',
-        required: true,
-    }),
-};
-export const testingYesFlag = {
-    yes: Flags.boolean({
-        char: 'y',
-        default: false,
-        description: 'Skip the destructive confirmation prompt.',
-    }),
-};
-export const testingSecretInputFlags = {
-    'no-trim': Flags.boolean({
-        default: false,
-        description: 'Preserve leading and trailing whitespace in the supplied value.',
-        exclusive: ['trim'],
-    }),
-    trim: Flags.boolean({
-        default: false,
-        description: 'Trim leading and trailing whitespace (the default policy).',
-        exclusive: ['no-trim'],
-    }),
-    value: Flags.string({
-        description: 'Value supplied directly. Prefer file/stdin for sensitive values.',
-        exclusive: ['value-file', 'value-stdin'],
-    }),
-    'value-file': Flags.string({
-        description: 'Read the value from a bounded regular file.',
-        exclusive: ['value', 'value-stdin'],
-    }),
-    'value-stdin': Flags.boolean({
-        default: false,
-        description: 'Read the value from stdin.',
-        exclusive: ['value', 'value-file'],
-    }),
-};
-export const testingJobFlag = {
-    job: Flags.integer({
-        char: 'j',
-        description: 'CRT job/test ID.',
-        required: true,
-    }),
-};
-export const testingBranchFlag = {
-    branch: Flags.string({
-        description: 'Optional CRT branch name for file operations.',
-    }),
-};
-export const testingRunOptionFlags = {
-    branch: Flags.string({
-        description: 'Git branch/ref to use for this run. Mutually exclusive with --tag.',
-    }),
-    'console-colors': Flags.option({
-        description: 'Control Robot Framework console colors.',
-        options: [...TESTING_CONSOLE_COLORS],
-    })(),
-    'console-width': Flags.integer({
-        description: 'Set Robot Framework console width.',
-        min: 1,
-    }),
-    datatable: Flags.string({
-        description: 'Data table and 1-based datasets as TABLE_ID:1,2-4. Repeat for zipped table selections.',
-        multiple: true,
-    }),
-    doc: Flags.string({
-        description: 'Set top-level Robot Framework suite documentation.',
-    }),
-    'dry-run': Flags.boolean({
-        default: false,
-        description: 'Validate Robot Framework data without executing library keywords.',
-    }),
-    exclude: Flags.string({
-        description: 'Robot Framework tag to exclude from this run. Can be provided multiple times.',
-        multiple: true,
-    }),
-    'exit-on-error': Flags.boolean({
-        default: false,
-        description: 'Stop execution when Robot Framework encounters a data or import error.',
-    }),
-    'exit-on-failure': Flags.boolean({
-        default: false,
-        description: 'Stop execution when a critical Robot Framework test fails.',
-    }),
-    include: Flags.string({
-        description: 'Robot Framework tag to include in this run. Can be provided multiple times.',
-        multiple: true,
-    }),
-    metadata: Flags.string({
-        description: 'Robot Framework suite metadata. Can be provided multiple times.',
-        multiple: true,
-    }),
-    name: Flags.string({
-        description: 'Set the top-level Robot Framework suite name.',
-    }),
-    'no-exit-code': Flags.boolean({
-        default: false,
-        description: 'Return exit code zero even when the waited CRT run fails.',
-    }),
-    param: Flags.string({
-        description: 'Execution parameter in KEY=VALUE format. Can be provided multiple times.',
-        multiple: true,
-    }),
-    record: Flags.option({
-        description: 'CRT execution recording mode.',
-        options: [...TESTING_RECORD_BUILD_OPTIONS],
-    })(),
-    'rerun-failed': Flags.integer({
-        description: 'Rerun failed tests from the specified build/run ID. Mutually exclusive with --rerun-failed-from-latest.',
-    }),
-    'rerun-failed-from-latest': Flags.boolean({
-        default: false,
-        description: 'Rerun failed tests from the latest failed run. Mutually exclusive with --rerun-failed.',
-    }),
-    'run-empty-suite': Flags.boolean({
-        default: false,
-        description: 'Execute even when the selected Robot Framework suite is empty.',
-    }),
-    'run-type': Flags.option({
-        description: 'CRT run type. Regression is sent as normal; development is sent unchanged.',
-        options: [...TESTING_RUN_TYPES],
-    })(),
-    'save-artifacts': Flags.string({
-        description: 'Save the completed run output ZIP to this explicit file path.',
-    }),
-    'set-tag': Flags.string({
-        description: 'Set a tag on all executed tests. Can be provided multiple times.',
-        multiple: true,
-    }),
-    skip: Flags.string({
-        description: 'Skip tests matching this tag. Can be provided multiple times.',
-        multiple: true,
-    }),
-    'skip-on-failure': Flags.string({
-        description: 'Skip failures for tests matching this tag. Can be provided multiple times.',
-        multiple: true,
-    }),
-    'stream-logs': Flags.boolean({
-        default: false,
-        description: 'Stream new CRT log text while waiting (human output only).',
-    }),
-    suite: Flags.string({
-        description: 'Select a Robot Framework suite. Can be provided multiple times.',
-        multiple: true,
-    }),
-    tag: Flags.string({
-        description: 'Git tag to use for this run. Mutually exclusive with --branch.',
-    }),
-    test: Flags.string({
-        description: 'Select a Robot Framework test/task. Can be provided multiple times.',
-        multiple: true,
-    }),
-    timeout: Flags.integer({
-        default: 60,
-        description: 'Maximum number of minutes to wait for a terminal result.',
-        min: 1,
-    }),
-    variable: Flags.string({
-        description: 'Set a Robot Framework variable. Can be provided multiple times.',
-        multiple: true,
-    }),
-    'wait-for-result': Flags.boolean({
-        default: false,
-        description: 'Poll CRT until the started build reaches a terminal result.',
-    }),
-    watch: Flags.string({
-        description: 'Watch a directory and rerun after debounced file changes (human output only).',
-    }),
-    xunit: Flags.string({
-        description: 'Extract xunit_report.xml from completed run artifacts to this explicit file path.',
-    }),
-};
-export const testingOutputFlags = {
-    output: Flags.string({
-        char: 'o',
-        description: 'Write raw output to this file path.',
-    }),
-};
-export const testingLogOptionFlags = {
-    container: Flags.string({
-        description: 'Read a specific CRT log stream/container.',
-    }),
-    'limit-bytes': Flags.integer({
-        description: 'Limit fetched log data to this many bytes.',
-        min: 1,
-    }),
-    pretty: Flags.boolean({
-        default: false,
-        description: 'Request readable log formatting.',
-    }),
-    'since-seconds': Flags.integer({
-        description: 'Fetch log lines from the last N seconds.',
-        min: 0,
-    }),
-    'tail-lines': Flags.integer({
-        description: 'Return only the last N log lines.',
-        min: 0,
-    }),
-    timestamps: Flags.boolean({
-        default: false,
-        description: 'Add timestamps to log lines.',
-    }),
-};
-export const testingFileInputFlags = {
-    dir: Flags.string({
-        description: 'Directory containing Robot Framework files to upload. Can be provided multiple times.',
-        multiple: true,
-    }),
-    file: Flags.string({
-        char: 'f',
-        description: 'Robot Framework file to upload. Can be provided multiple times.',
-        multiple: true,
-    }),
-};
-export const testingGitStorageFlags = {
-    'git-branch': Flags.string({
-        description: 'Git branch to use for a Git-backed CRT job. Mutually exclusive with --git-tag.',
-    }),
-    'git-domain-credential': Flags.string({
-        description: 'CRT domain credential ID to use for Git repository access.',
-    }),
-    'git-password': Flags.string({
-        description: 'Git password/token for repository access. Prefer --git-domain-credential when available.',
-        exclusive: ['git-password-file', 'git-password-stdin'],
-    }),
-    'git-password-file': Flags.string({
-        description: 'Read a bounded Git password/token from a regular file.',
-        exclusive: ['git-password', 'git-password-stdin'],
-    }),
-    'git-password-stdin': Flags.boolean({
-        default: false,
-        description: 'Read a Git password/token from stdin.',
-        exclusive: ['git-password', 'git-password-file'],
-    }),
-    'git-tag': Flags.string({
-        description: 'Git tag to use for a Git-backed CRT job. Mutually exclusive with --git-branch.',
-    }),
-    'git-url': Flags.string({
-        description: 'Git repository URL for a Git-backed CRT job.',
-    }),
-    'git-use-caller-credentials': Flags.boolean({
-        default: false,
-        description: 'Use caller credentials for Git repository access instead of explicit Git username/password.',
-    }),
-    'git-username': Flags.string({
-        description: 'Git username for repository access. Prefer --git-domain-credential when available.',
-    }),
-};
-export const testingUploadOperationFlags = {
-    add: Flags.string({
-        description: 'Add a file using local[:remote] syntax. Can be provided multiple times.',
-        multiple: true,
-    }),
-    remove: Flags.string({
-        description: 'Remove a remote CRT file path. Can be provided multiple times.',
-        multiple: true,
-    }),
-    replace: Flags.string({
-        description: 'Replace a file using local[:remote] syntax. Can be provided multiple times.',
-        multiple: true,
-    }),
-};
-export function testingRunOptions(flags, ids) {
-    if (flags.branch !== undefined && flags.tag !== undefined) {
-        throw new Error('Use either --branch or --tag, not both.');
-    }
-    if (flags['rerun-failed'] !== undefined && flags['rerun-failed-from-latest'] === true) {
-        throw new Error('Use either --rerun-failed or --rerun-failed-from-latest, not both.');
-    }
-    return {
-        branch: flags.branch,
-        consoleColors: flags['console-colors'],
-        consoleWidth: flags['console-width'],
-        dataTables: flags.datatable,
-        doc: flags.doc,
-        dryRun: flags['dry-run'],
-        exclude: flags.exclude,
-        exitOnError: flags['exit-on-error'],
-        exitOnFailure: flags['exit-on-failure'],
-        include: flags.include,
-        jobId: ids.jobId,
-        metadata: flags.metadata,
-        name: flags.name,
-        parameters: (flags.param ?? []).map((param) => parseTestingParameter(param)),
-        projectId: ids.projectId,
-        record: flags.record,
-        rerunFailedFromLatest: flags['rerun-failed-from-latest'] === true ? true : undefined,
-        rerunFailedId: flags['rerun-failed'],
-        runEmptySuite: flags['run-empty-suite'],
-        runType: flags['run-type'],
-        setTags: flags['set-tag'],
-        skip: flags.skip,
-        skipOnFailure: flags['skip-on-failure'],
-        suites: flags.suite,
-        tag: flags.tag,
-        tests: flags.test,
-        variables: flags.variable,
-    };
-}
-function parseTestingParameter(spec) {
-    const separator = spec.indexOf('=');
-    const key = separator === -1 ? spec.trim() : spec.slice(0, separator).trim();
-    if (separator === -1 || key.length === 0) {
-        throw new Error(`Invalid execution parameter: ${spec}. Use KEY=VALUE.`);
-    }
-    return { key, value: spec.slice(separator + 1) };
-}
-//# sourceMappingURL=testing-flags.js.map
+import {modules} from './runtime.js';
+const testingBranchFlag = modules["testing-flags.js"]["testingBranchFlag"]
+const testingFileInputFlags = modules["testing-flags.js"]["testingFileInputFlags"]
+const testingGitStorageFlags = modules["testing-flags.js"]["testingGitStorageFlags"]
+const testingJobFlag = modules["testing-flags.js"]["testingJobFlag"]
+const testingLogOptionFlags = modules["testing-flags.js"]["testingLogOptionFlags"]
+const testingOutputFlags = modules["testing-flags.js"]["testingOutputFlags"]
+const testingProjectFlag = modules["testing-flags.js"]["testingProjectFlag"]
+const testingRunOptionFlags = modules["testing-flags.js"]["testingRunOptionFlags"]
+const testingRunOptions = modules["testing-flags.js"]["testingRunOptions"]
+const testingSecretInputFlags = modules["testing-flags.js"]["testingSecretInputFlags"]
+const testingUploadOperationFlags = modules["testing-flags.js"]["testingUploadOperationFlags"]
+const testingYesFlag = modules["testing-flags.js"]["testingYesFlag"]
+export {testingBranchFlag, testingFileInputFlags, testingGitStorageFlags, testingJobFlag, testingLogOptionFlags, testingOutputFlags, testingProjectFlag, testingRunOptionFlags, testingRunOptions, testingSecretInputFlags, testingUploadOperationFlags, testingYesFlag};