codefresh 0.78.2

package/lib/interface/cli/completion/completion.spec.js

@@ -0,0 +1,313 @@
+const initCompletion = require('./index');
+const { handleOptions: mockHandleOptions, fileDir: mockFileDir } = require('./helpers');
+const mockPath = require('path');
+
+const completions = initCompletion();
+
+function getCompletion(args) {
+    return new Promise(resolve => completions.getCompletion(args, resolve));
+}
+
+jest.mock('./tree', () => ({
+    codefresh: {
+        get: {
+            pipelines: {
+                __positionalHandler: './pipelines/get.completion',
+            },
+            pip: {
+                alias: 'pipelines',
+            },
+            __optionHandlers: ['./pipelines/get.completion'],
+        },
+        generate: {},
+        create: {
+            context: {
+                git: {},
+                config: {},
+                __optionHandlers: ['./context/create.completion', './root/create.completion'],
+            },
+            repository: {},
+            __optionHandlers: ['./root/create.completion', './root/another.completion'],
+        },
+        crt: {
+            alias: 'create',
+            context: {
+                git_of_alias: {}, // typically should be equal to create.context, just for test
+                config: {},
+            },
+            repository: {},
+        },
+    },
+}), { virtual: true });
+
+jest.mock('./pipelines/get.completion', () => { // eslint-disable-line
+    return {
+        positionalHandler: () => ['1_pip', '2_pip'],
+        optionHandler: mockHandleOptions(['-f', '--filename'], ({ word }) => mockFileDir(word)),
+    };
+}, { virtual: true });
+
+jest.mock('./root/create.completion', () => { // eslint-disable-line
+    return {
+        optionHandler: mockHandleOptions(['-f', '--filename'], () => ['param1', 'param2']),
+    };
+}, { virtual: true });
+
+jest.mock('./root/another.completion', () => { // eslint-disable-line
+    return {
+        optionHandler: mockHandleOptions(['--another'], () => ['another']),
+    };
+}, { virtual: true });
+
+jest.mock('./context/create.completion', () => { // eslint-disable-line
+    return {
+        optionHandler: mockHandleOptions(['-f', '--filename'], () => ['param1']),
+    };
+}, { virtual: true });
+
+jest.mock('fs', () => {
+    const existsSync = (p) => {
+        if (p.startsWith(`${process.cwd()}/`)) {
+            p = p.replace(`${process.cwd()}/`, '');
+        }
+        if (p.startsWith(process.cwd())) {
+            p = p.replace(process.cwd(), '');
+        }
+        switch (p) {
+            case '':
+            case 'libe/':
+            case 'libe':
+            case 'another':
+            case 'another/':
+            case 'libe/cli':
+            case 'libe/cli/':
+                return true;
+            default:
+                return false;
+        }
+    };
+    const lstatSync = (p) => {
+        let isFile = false;
+        let isDir = true;
+        if (p.startsWith(`${process.cwd()}/`)) {
+            p = p.replace(`${process.cwd()}/`, '');
+        }
+        if (p.startsWith(process.cwd())) {
+            p = p.replace(process.cwd(), '');
+        }
+        switch (p) {
+            case 'some.yaml':
+            case 'libe/another.yaml':
+                isFile = true;
+                isDir = false;
+                break;
+            default:
+                break;
+        }
+        return {
+            isFile: () => isFile,
+            isDirectory: () => isDir,
+        };
+    };
+
+    const stat = (p, options = { bigint: false }, callback) => {
+        const result = lstatSync(p);
+        return callback(null, result);
+    };
+
+    const readdirSync = (p) => {
+        if (p.startsWith(`${process.cwd()}/`)) {
+            p = p.replace(`${process.cwd()}/`, '');
+        }
+        if (p.startsWith(process.cwd())) {
+            p = p.replace(process.cwd(), '');
+        }
+        switch (p) {
+            case '':
+                return ['libe', 'like', 'another', 'some.yaml'];
+            case 'libe':
+            case 'libe/':
+                return ['cli', 'clo', 'another.yaml'];
+            default:
+                return [];
+        }
+    };
+    return Object.assign(jest.requireActual('fs'), {
+        lstat: (p, options, callback) => callback(null, lstatSync(p)),
+        stat: (p, options, callback) => callback(null, lstatSync(p)),
+        access: (path, c) => c(null, true),
+        readdirSync,
+        existsSync,
+        lstatSync,
+    });
+});
+
+process.argv = []; // completion is sensitive to process args
+
+describe('codefresh completions', () => {
+    describe('static', () => {
+        it('should not display any completions when no word is entered', async () => {
+            const result = await getCompletion([]);
+            expect(result).toEqual([]);
+        });
+
+        it('should not display any completions when wrong word is entered', async () => {
+            const result = await getCompletion(['codefresh', 'asdf']);
+            expect(result).toEqual([]);
+        });
+
+        it('should not display any completions when multiple wrong words are entered', async () => {
+            const result = await getCompletion(['codefresh', 'asdf', 'qwer']);
+            expect(result).toEqual([]);
+        });
+
+        it('should display only full commands completions', async () => {
+            const result = await getCompletion(['codefresh', '']);
+            expect(result).toEqual(['get', 'generate', 'create']);
+        });
+
+        it('should display full commands and not alias completions (when they are not fully entered)', async () => {
+            const result = await getCompletion(['codefresh', 'cr']);
+            expect(result).toEqual(['create']);
+        });
+
+        it('should display alias completion when it\'s fully entered and full command not starts with it', async () => {
+            const result = await getCompletion(['codefresh', 'crt']);
+            expect(result).toEqual(['crt']);
+        });
+
+        it('should resolve alias command descendants', async () => {
+            const result = await getCompletion(['codefresh', 'crt', 'context', '']);
+            expect(result).toEqual(['git_of_alias', 'config']);
+        });
+    });
+
+    describe('dynamic', () => {
+        it('should display function result when completion resolves to __positionalHandler', async () => {
+            const result = await getCompletion(['codefresh', 'get', 'pipelines', '']);
+            expect(result).toEqual(['1_pip', '2_pip']);
+        });
+
+        it('should call full command __positionalHandler when alias is entered', async () => {
+            const result = await getCompletion(['codefresh', 'get', 'pip', '']);
+            expect(result).toEqual(['1_pip', '2_pip']);
+        });
+
+        it('should display function result when wrong word is entered and command path resolves to __positionalHandler', async () => {
+            const result = await getCompletion(['codefresh', 'get', 'pip', 'asdf', 'qwer']);
+            expect(result).toEqual(['1_pip', '2_pip']);
+        });
+
+        it('should display option completions when arg before last is option and completion has __optionHandlers', async () => {
+            process.argv = ['codefresh', 'create', '-f', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['param1', 'param2']);
+        });
+
+        it('should display option completions exactly for provided option', async () => {
+            process.argv = ['codefresh', 'create', '--another', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['another']);
+        });
+
+        it('should resolve alias as full command when arg before last is option', async () => {
+            process.argv = ['codefresh', 'crt', '-f', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['param1', 'param2']);
+        });
+
+        it('should not display any option completions when it has no __optionHandlers', async () => {
+            process.argv = ['codefresh', 'generate', '-f', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual([]);
+        });
+
+        // option handler overriding
+        it('should display option completions from first handler when option is supported by some of __optionHandlers', async () => {
+            process.argv = ['codefresh', 'create', 'context', '-f', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['param1']);
+        });
+
+        it('should not display any option completions when option is not supported by any of __optionHandlers', async () => {
+            process.argv = ['codefresh', 'create', '--notSupported', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual([]);
+        });
+
+        it('should display next commands completions when option is provided with a value', async () => {
+            process.argv = ['codefresh', 'create', '-f', 'value', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['context', 'repository']);
+        });
+    });
+
+    describe('filedir', () => {
+        it('should return "__files_completion__" literal to shell without --impl-file-dir', async () => {
+            process.argv = ['codefresh', 'get', '-f', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__']);
+        });
+
+        it('should list dirs and yaml files when no word passed', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', ''];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'libe/', 'like/', 'another/', 'some.yaml']);
+        });
+
+        it('should return only one file when passed word resolves to it', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'some'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'some.yaml']);
+        });
+
+        it('should filter dirs and yaml files by word passed', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'li'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'libe/', 'like/']);
+        });
+
+        it('should return stubs prefixed by dir when passed word resolves to only one dir', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'lib'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'libe/1', 'libe/2']);
+        });
+
+        it('should return dir with slash when passed word resolves to empty dir', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'another/'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'another/']);
+        });
+
+        it('should return stubs prefixed by word when it equals dir name', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'libe'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'libe/1', 'libe/2']);
+        });
+
+        it('should list dirs and yamls prefixed by word when it equals dir name with slash', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'libe/'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'libe/cli/', 'libe/clo/', 'libe/another.yaml']);
+        });
+
+        it('should filter dirs and yamls by suffix when prefix equals dir', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'libe/cl'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'libe/cli/', 'libe/clo/']);
+        });
+
+
+        it('should stubs when prefix + suffix equals dir', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'libe/cli'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'libe/cli/1', 'libe/cli/2']);
+        });
+
+        it('should return yaml prefixed by word when prefix equals dir and suffix resolves to this yaml', async () => {
+            process.argv = ['codefresh', 'get', '--impl-zsh-file-dir', '-f', 'libe/another'];
+            const result = await getCompletion(process.argv);
+            expect(result).toEqual(['__files_completion__', 'libe/another.yaml']);
+        });
+    });
+});

package/lib/interface/cli/completion/generate

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const recursive = require('recursive-readdir');
+const _ = require('lodash');
+const fs = require('fs');
+
+function _resolveCommandName(command) {
+    return command.command.split(' ')[0];
+}
+
+function _buildSubCommandTree(command) {
+    let subCommandTree = {
+        __positionalHandler: command.positionalHandler ? command.completionPath : undefined,
+        __optionHandlers: command.optionHandlers,
+    };
+    const commandName = _resolveCommandName(command);
+    if (!_.isEmpty(command.subCommands)) {
+        const subTrees = command.subCommands.map(c => _buildSubCommandTree(c));
+        subCommandTree = _.assignIn(subCommandTree, ...subTrees);
+    }
+    const commandTree = { [commandName]: subCommandTree };
+    command.aliases.forEach((alias) => {
+        // alias is for dynamic completion and subCommandTree is for cascade aliased commands
+        commandTree[alias] = _.assignIn({ alias: commandName }, subCommandTree);
+        commandTree[alias].__positionalHandler = undefined;
+        commandTree[alias].__optionHandlers = undefined;
+    });
+    return commandTree;
+}
+
+function _setHandlersRecursively(command, optionHandler, isRoot = false) {
+    if (!optionHandler) {
+        if (isRoot) {
+            _setHandlersRecursively(command, command.optionHandler ? command.completionPath : null);
+            if (!_.isEmpty(command.subCommands)) {
+                command.subCommands.forEach((sc) => {
+                    _setHandlersRecursively(sc, null, true);
+                });
+            }
+        }
+        return;
+    }
+
+    command.optionHandlers = _.concat([optionHandler], command.optionHandlers || []);
+    if (!_.isEmpty(command.subCommands)) {
+        command.subCommands.forEach((sc) => {
+            _setHandlersRecursively(sc, optionHandler);
+        });
+    }
+}
+
+function _validateRecursively(command) {
+    if (!_.isEmpty(command.subCommands)) {
+        if (command.positionalHandler) {
+            throw new Error(`This command cannot have positional completions -- it has sub-commands. Path: ${command.completionPath}`);
+        }
+        command.subCommands.forEach(_validateRecursively);
+    }
+}
+
+async function generate() {
+    const rootCommands = [];
+    const files = await recursive(path.resolve(__dirname, '..', 'commands'));
+    _.forEach(files, (file) => {
+        if (file.endsWith('.cmd.js')) {
+            const command = require(file);
+            if (command.isRoot()) {
+                rootCommands.push(command);
+            }
+            const completionPath = file.replace('.cmd.js', '.completion.js');
+            if (fs.existsSync(completionPath)) {
+                const completion = require(completionPath);
+                command.completionPath = path.relative(path.resolve(__dirname), completionPath); // relative to completion folder
+                command.optionHandler = completion.optionHandler;
+                command.positionalHandler = completion.positionalHandler;
+            }
+        }
+    });
+
+    rootCommands.forEach(_validateRecursively);
+    rootCommands.forEach(rc => _setHandlersRecursively(rc, null, true));
+
+    const rootSubTrees = rootCommands.map(c => _buildSubCommandTree(c));
+    const tree = {
+        codefresh: _.assignIn({}, ...rootSubTrees),
+    };
+
+    const treeString = JSON.stringify(tree);
+    fs.writeFileSync(path.resolve(__dirname, 'tree.json'), treeString);
+
+    console.log('Completion tree successfully generated:');
+    console.log(treeString);
+}
+
+if (process.argv.includes(__filename)) {
+    generate().catch((err) => {
+        console.error(err.stack);
+        process.exit(1);
+    });
+}
+

package/lib/interface/cli/completion/helpers.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const path = require('path');
+const _ = require('lodash');
+const sdk = require('../../../logic/sdk');
+const { Config } = require('codefresh-sdk');
+
+const EXT_REG_EX = /.*\.(yaml|yml|json)$/;
+
+/**
+ *  load auth context for dynamic completion
+ *
+ *  params are:
+ *      { word, argv, option }
+ *      or
+ *      { word, argv }
+ * */
+function authContextWrapper(func) {
+    return async (params) => {
+        sdk.configure(await Config.load({ request: { retryStrategy: () => false } }));
+        return func(params);
+    };
+}
+
+/**
+ * params are always { word, argv, option }
+ * */
+function handleOptions(options, handler) {
+    return (params) => {
+        if (options.includes(params.option)) {
+            return handler(params);
+        }
+        return null;
+    };
+}
+
+function _listFilesDirs(cwd) {
+    return fs.readdirSync(cwd)
+        .map(p => path.basename(p))
+        .filter(p => EXT_REG_EX.test(p) || fs.lstatSync(path.resolve(cwd, p)).isDirectory());
+}
+
+/**
+ * This function is specialised on providing file-dir completions.
+ *
+ * When '--impl-zsh-file-dir' is not passed it will return "__files_completion__" literal,
+ * which means that shell must generate file-dir completions itself (bash case).
+ *
+ * Otherwise function will generate file-dir completions specifically oriented on zsh.
+ * */
+function fileDir(word) {
+    if (!process.argv.includes('--impl-zsh-file-dir')) {
+        return ['__files_completion__'];
+    }
+
+    let cwd = path.resolve(process.cwd(), word);
+    const pathExists = fs.existsSync(cwd);
+    if (pathExists && fs.lstatSync(cwd).isDirectory() && !_.isEmpty(word) && !word.endsWith('/')) {
+        return ['__files_completion__', `${word}/1`, `${word}/2`];
+    }
+
+    const suffix = word.endsWith('/') ? '' : path.basename(word);
+    let prefix = word.replace(new RegExp(`${suffix}$`), '');
+    if (!pathExists) {
+        cwd = cwd.replace(new RegExp(`${suffix}$`), '');
+    }
+
+    let res = _listFilesDirs(cwd)
+        .filter(p => p.startsWith(suffix))
+        .map(p => (EXT_REG_EX.test(p) || fs.lstatSync(path.resolve(cwd, p)).isFile()) ? p : `${p}/`);
+
+    if (res.length === 1 && fs.lstatSync(path.resolve(cwd, res[0])).isDirectory()) {
+        prefix = `${prefix}${res[0]}`;
+        res = ['1', '2']; // will complete just to dir's slash
+    }
+
+    // when dir has no sub-dirs or appr. files return to completion script just prefix
+    if (res.length === 0) {
+        res.push('');
+    }
+
+    res = res.map(p => `${prefix}${p}`);
+
+    return ['__files_completion__', ...res];
+}
+
+module.exports = {
+    authContextWrapper,
+    handleOptions,
+    fileDir,
+};

package/lib/interface/cli/completion/index.js

@@ -0,0 +1,89 @@
+const yargs = require('yargs');
+const _ = require('lodash');
+
+let tree;
+try {
+    tree = require('./tree'); // tree is generated at build phase
+} catch (e) {
+    // cannot do any log -- will be displayed as completion due to bash
+    tree = {};
+}
+
+function completionInterface() {
+    return yargs
+        .completion('completion', async (word, argv) => {
+            let args = argv._.filter(a => !_.isEmpty(a));
+            if (!_.isEmpty(args)) {
+                args[0] = 'codefresh'; // first arg is always executable name (can be any alias)
+            }
+
+            let commandPath = args.join('.');
+            let result = _.get(tree, commandPath);
+            let lastWord = '';
+
+            // remove all positional or last word that not resolves any completion descendants
+            while (!result && args.length) {
+                lastWord = _.last(args);
+                args = args.slice(0, -1);
+                commandPath = args.join('.');
+                result = _.get(tree, commandPath);
+            }
+
+            // when last word resolves completion descendants, check if it has no siblings from parent
+            if (!_.isEmpty(word) && _.isEmpty(lastWord) && args.length && _.last(args) === word) {
+                lastWord = word;
+                args = args.slice(0, -1);
+                commandPath = args.join('.');
+                result = _.get(tree, commandPath);
+            }
+
+            // replace alias with its real (needed when completion executes function, for future dynamic completion)
+            if (result && result.alias) {
+                const realPath = `${args.slice(0, -1).join('.')}.${result.alias}`;
+                result = _.get(tree, realPath);
+            }
+
+            if (result) {
+                const pArgv = process.argv;
+                const optionArg = pArgv.length > 2 ? pArgv[pArgv.length - 2] : null;
+                if (optionArg && optionArg.startsWith('-')) {
+                    if (result.__optionHandlers) {
+                        try {
+                            for (const handlerPath of result.__optionHandlers) {
+                                const handler = require(handlerPath).optionHandler;
+                                const completions = await handler({ word, argv, option: optionArg });
+                                if (_.isArray(completions)) {
+                                    return completions;
+                                }
+                            }
+                            return [];
+                        } catch (e) {
+                            return [];
+                        }
+                    } else {
+                        return [];
+                    }
+                }
+
+                if (result.__positionalHandler) {
+                    try {
+                        const handler = require(result.__positionalHandler).positionalHandler;
+                        return await handler({ word, argv });
+                    } catch (e) {
+                        return [];
+                    }
+                }
+                if (_.isObject(result)) {
+                    return _.keys(result).filter((k) => {
+                        // do not display aliases on completion unless alias is entered fully
+                        // and real command not starts with its alias (example: context and ctx)
+                        const alias = _.get(result, k).alias;
+                        return !k.startsWith('__') && ((alias && !alias.startsWith(k) && word === k) || (!alias && k.startsWith(lastWord)));
+                    });
+                }
+            }
+            return [];
+        });
+}
+
+module.exports = completionInterface;

package/lib/interface/cli/completion/tree.json

@@ -0,0 +1 @@
+{"codefresh":{"analyze":{},"completion":{},"completions":{"alias":"completion"},"tag":{},"untag":{},"offline-logs":{"ensure-index":{},"offload-to-collection":{},"offload-to-file":{}},"run":{"__optionHandlers":["../commands/pipeline/run.completion.js"]},"attach":{},"add":{"repository":{},"repo":{"alias":"repository"}},"annotate":{"image":{},"img":{"alias":"image"}},"patch":{"__optionHandlers":["../commands/root/apply.completion.js"],"agent":{"__optionHandlers":["../commands/root/apply.completion.js"]},"board":{"__optionHandlers":["../commands/root/apply.completion.js"]},"project":{"__optionHandlers":["../commands/root/apply.completion.js"]},"runtime-environments":{"__optionHandlers":["../commands/root/apply.completion.js"]},"re":{"alias":"runtime-environments"},"runtime-environment":{"alias":"runtime-environments"},"section":{"__optionHandlers":["../commands/root/apply.completion.js"]},"system-runtime-environments":{"__optionHandlers":["../commands/root/apply.completion.js"]},"sys-re":{"alias":"system-runtime-environments"},"system-runtime-environment":{"alias":"system-runtime-environments"},"teams":{"__optionHandlers":["../commands/root/apply.completion.js"]},"team":{"alias":"teams"},"tm":{"alias":"teams"},"tokens":{"__optionHandlers":["../commands/root/apply.completion.js"]},"token":{"alias":"tokens"},"helm-repo":{"__optionHandlers":["../commands/root/apply.completion.js"]},"context":{"__optionHandlers":["../commands/root/apply.completion.js"]},"ctx":{"alias":"context"}},"auth":{"create-context":{},"current-context":{},"get-contexts":{},"use-context":{}},"components":{"update":{}},"create":{"__optionHandlers":["../commands/root/create.completion.js"],"agent":{"__optionHandlers":["../commands/root/create.completion.js"]},"clusters":{"__optionHandlers":["../commands/root/create.completion.js"]},"cluster":{"alias":"clusters"},"annotation":{"__optionHandlers":["../commands/root/create.completion.js"]},"board":{"__optionHandlers":["../commands/root/create.completion.js"]},"composition":{"__optionHandlers":["../commands/composition/create.completion.js","../commands/root/create.completion.js"]},"com":{"alias":"composition"},"project":{"__optionHandlers":["../commands/root/create.completion.js"]},"runtime-environments":{"__optionHandlers":["../commands/root/create.completion.js"]},"re":{"alias":"runtime-environments"},"runtime-environment":{"alias":"runtime-environments"},"section":{"__optionHandlers":["../commands/root/create.completion.js"]},"teams":{"__optionHandlers":["../commands/root/create.completion.js"]},"team":{"alias":"teams"},"tm":{"alias":"teams"},"token":{"__optionHandlers":["../commands/root/create.completion.js"]},"helm-repo":{"__optionHandlers":["../commands/root/create.completion.js"]},"registry":{"__optionHandlers":["../commands/root/create.completion.js"],"standard":{"__optionHandlers":["../commands/root/create.completion.js"]}},"trigger":{"__optionHandlers":["../commands/root/create.completion.js"]},"t":{"alias":"trigger"},"trigger-event":{"__optionHandlers":["../commands/root/create.completion.js"]},"te":{"alias":"trigger-event"},"workflow-data-item":{"__optionHandlers":["../commands/root/create.completion.js"]},"wdi":{"alias":"workflow-data-item"},"context":{"__optionHandlers":["../commands/root/create.completion.js"],"config":{"__optionHandlers":["../commands/root/create.completion.js"]},"secret":{"__optionHandlers":["../commands/root/create.completion.js"]},"secret-yaml":{"__optionHandlers":["../commands/root/create.completion.js"]},"yaml":{"__optionHandlers":["../commands/root/create.completion.js"]},"git":{"__optionHandlers":["../commands/root/create.completion.js"],"bitbucket":{"__optionHandlers":["../commands/root/create.completion.js"]},"github":{"__optionHandlers":["../commands/root/create.completion.js"]},"gitlab":{"__optionHandlers":["../commands/root/create.completion.js"]},"stash":{"__optionHandlers":["../commands/root/create.completion.js"]}},"helm-repository":{"__optionHandlers":["../commands/root/create.completion.js"],"http":{"__optionHandlers":["../commands/root/create.completion.js"]},"s3":{"__optionHandlers":["../commands/root/create.completion.js"]}},"secret-store":{"__optionHandlers":["../commands/root/create.completion.js"],"hashicorp-vault":{"__optionHandlers":["../commands/root/create.completion.js"]},"kubernetes-runtime":{"__optionHandlers":["../commands/root/create.completion.js"]},"kubernetes":{"__optionHandlers":["../commands/root/create.completion.js"]}}},"ctx":{"alias":"context","config":{"__optionHandlers":["../commands/root/create.completion.js"]},"secret":{"__optionHandlers":["../commands/root/create.completion.js"]},"secret-yaml":{"__optionHandlers":["../commands/root/create.completion.js"]},"yaml":{"__optionHandlers":["../commands/root/create.completion.js"]},"git":{"__optionHandlers":["../commands/root/create.completion.js"],"bitbucket":{"__optionHandlers":["../commands/root/create.completion.js"]},"github":{"__optionHandlers":["../commands/root/create.completion.js"]},"gitlab":{"__optionHandlers":["../commands/root/create.completion.js"]},"stash":{"__optionHandlers":["../commands/root/create.completion.js"]}},"helm-repository":{"__optionHandlers":["../commands/root/create.completion.js"],"http":{"__optionHandlers":["../commands/root/create.completion.js"]},"s3":{"__optionHandlers":["../commands/root/create.completion.js"]}},"secret-store":{"__optionHandlers":["../commands/root/create.completion.js"],"hashicorp-vault":{"__optionHandlers":["../commands/root/create.completion.js"]},"kubernetes-runtime":{"__optionHandlers":["../commands/root/create.completion.js"]},"kubernetes":{"__optionHandlers":["../commands/root/create.completion.js"]}}}},"delete":{"__optionHandlers":["../commands/root/delete.completion.js"],"agent":{"__optionHandlers":["../commands/root/delete.completion.js"]},"annotation":{"__optionHandlers":["../commands/root/delete.completion.js"]},"board":{"__optionHandlers":["../commands/root/delete.completion.js"]},"cluster":{"__optionHandlers":["../commands/root/delete.completion.js"]},"clusters":{"alias":"cluster"},"composition":{"__optionHandlers":["../commands/root/delete.completion.js"]},"com":{"alias":"composition"},"environment":{"__optionHandlers":["../commands/root/delete.completion.js"]},"env":{"alias":"environment"},"pipeline":{"__optionHandlers":["../commands/root/delete.completion.js"]},"pip":{"alias":"pipeline"},"project":{"__optionHandlers":["../commands/root/delete.completion.js"]},"repository":{"__optionHandlers":["../commands/root/delete.completion.js"]},"repo":{"alias":"repository"},"runtime-environments":{"__optionHandlers":["../commands/root/delete.completion.js"]},"re":{"alias":"runtime-environments"},"runtime-environment":{"alias":"runtime-environments"},"section":{"__optionHandlers":["../commands/root/delete.completion.js"]},"step-type":{"__optionHandlers":["../commands/root/delete.completion.js"]},"system-runtime-environments":{"__optionHandlers":["../commands/root/delete.completion.js"]},"sys-re":{"alias":"system-runtime-environments"},"system-runtime-environment":{"alias":"system-runtime-environments"},"teams":{"__optionHandlers":["../commands/root/delete.completion.js"]},"team":{"alias":"teams"},"tm":{"alias":"teams"},"tokens":{"__optionHandlers":["../commands/root/delete.completion.js"]},"token":{"alias":"tokens"},"helm-repo":{"__optionHandlers":["../commands/root/delete.completion.js"]},"registry":{"__optionHandlers":["../commands/root/delete.completion.js"]},"trigger":{"__optionHandlers":["../commands/root/delete.completion.js"]},"t":{"alias":"trigger"},"trigger-event":{"__optionHandlers":["../commands/root/delete.completion.js"]},"te":{"alias":"trigger-event"},"context":{"__optionHandlers":["../commands/root/delete.completion.js"]},"ctx":{"alias":"context"}},"diff":{"__optionHandlers":["../commands/root/diff.completion.js"],"runtime-environments":{"__optionHandlers":["../commands/root/diff.completion.js"]},"re":{"alias":"runtime-environments"},"runtime-environment":{"alias":"runtime-environments"},"system-runtime-environments":{"__optionHandlers":["../commands/root/diff.completion.js"]},"sys-re":{"alias":"system-runtime-environments"},"system-runtime-environment":{"alias":"system-runtime-environments"}},"download":{"audit":{}},"generate":{"image-pull-secret":{}},"get":{"__optionHandlers":["../commands/root/get.completion.js"],"agents":{"__optionHandlers":["../commands/root/get.completion.js"]},"agent":{"alias":"agents"},"annotation":{"__optionHandlers":["../commands/root/get.completion.js"]},"boards":{"__optionHandlers":["../commands/root/get.completion.js"]},"board":{"alias":"boards"},"clusters":{"__optionHandlers":["../commands/root/get.completion.js"]},"cluster":{"alias":"clusters"},"compositions":{"__optionHandlers":["../commands/root/get.completion.js"]},"com":{"alias":"compositions"},"composition":{"alias":"compositions"},"environments":{"__optionHandlers":["../commands/root/get.completion.js"]},"env":{"alias":"environments"},"environment":{"alias":"environments"},"images":{"__optionHandlers":["../commands/root/get.completion.js"]},"img":{"alias":"images"},"image":{"alias":"images"},"pipelines":{"__positionalHandler":"../commands/pipeline/get.completion.js","__optionHandlers":["../commands/root/get.completion.js"]},"pip":{"alias":"pipelines"},"pipeline":{"alias":"pipelines"},"projects":{"__optionHandlers":["../commands/root/get.completion.js"]},"project":{"alias":"projects"},"repository":{"__optionHandlers":["../commands/root/get.completion.js"]},"repo":{"alias":"repository"},"runtime-environments":{"__optionHandlers":["../commands/root/get.completion.js"]},"re":{"alias":"runtime-environments"},"runtime-environment":{"alias":"runtime-environments"},"sections":{"__optionHandlers":["../commands/root/get.completion.js"]},"section":{"alias":"sections"},"step-types":{"__positionalHandler":"../commands/step/get.completion.js","__optionHandlers":["../commands/root/get.completion.js"]},"step-type":{"alias":"step-types"},"system-runtime-environments":{"__optionHandlers":["../commands/root/get.completion.js"]},"sys-re":{"alias":"system-runtime-environments"},"system-runtime-environment":{"alias":"system-runtime-environments"},"teams":{"__optionHandlers":["../commands/root/get.completion.js"]},"team":{"alias":"teams"},"tm":{"alias":"teams"},"tokens":{"__optionHandlers":["../commands/root/get.completion.js"]},"token":{"alias":"tokens"},"helm-repo":{"__optionHandlers":["../commands/root/get.completion.js"]},"registry":{"__optionHandlers":["../commands/root/get.completion.js"]},"triggers":{"__optionHandlers":["../commands/root/get.completion.js"]},"trigger":{"alias":"triggers"},"t":{"alias":"triggers"},"trigger-events":{"__optionHandlers":["../commands/root/get.completion.js"]},"trigger-event":{"alias":"trigger-events"},"te":{"alias":"trigger-events"},"trigger-types":{"__optionHandlers":["../commands/root/get.completion.js"]},"trigger-type":{"alias":"trigger-types"},"tt":{"alias":"trigger-types"},"builds":{"__optionHandlers":["../commands/root/get.completion.js"]},"build":{"alias":"builds"},"workflow-data-item":{"__optionHandlers":["../commands/root/get.completion.js"]},"wdi":{"alias":"workflow-data-item"},"contexts":{"__optionHandlers":["../commands/root/get.completion.js"]},"ctx":{"alias":"contexts"},"context":{"alias":"contexts"}},"install":{"runtime":{},"agent":{},"app-proxy":{},"monitor":{},"gitops":{}},"replace":{"__optionHandlers":["../commands/root/replace.completion.js"],"composition":{"__optionHandlers":["../commands/composition/replace.completion.js","../commands/root/replace.completion.js"]},"com":{"alias":"composition"}},"runner":{"delete":{},"execute-test-pipeline":{},"info":{},"init":{},"upgrade":{}},"synchronize":{"teams":{},"team":{"alias":"teams"},"tm":{"alias":"teams"}},"uninstall":{"agent":{},"app-proxy":{},"runtime":{},"monitor":{},"gitops":{}},"upgrade":{"app-proxy":{},"gitops":{}},"validate":{"__positionalHandler":"../commands/root/validate.completion.js"},"version":{},"cli-config":{"get":{},"help":{},"profile":{},"set":{}},"set-helm-config":{},"install-chart":{},"helm-promotion":{},"delete-release":{},"rollback-release":{},"test-release":{},"approve":{},"deny":{},"logs":{},"restart":{},"terminate":{},"wait":{}}}

package/lib/interface/cli/defaults.js

@@ -0,0 +1,18 @@
+const { homedir } = require('os');
+const path = require('path');
+
+const DEFAULTS = {
+    URL: 'https://g.codefresh.io',
+    CFCONFIG: `${process.env.HOME || process.env.USERPROFILE}/.cfconfig`,
+    DEBUG_PATTERN: 'codefresh',
+    GET_LIMIT_RESULTS: 25,
+    GET_ALL_PIPELINES_LIMIT: 10000,
+    GET_PAGINATED_PAGE: 1,
+    INTERNAL_REGISTRY_PREFIX: 'CFCR',
+    WATCH_INTERVAL_MS: 3000,
+    MAX_CONSECUTIVE_ERRORS_LIMIT: 10,
+    CODEFRESH_PATH: path.resolve(homedir(), '.Codefresh'),
+    ENGINE_IMAGE: process.env.ENGINE_IMAGE || 'codefresh/engine:master',
+};
+
+module.exports = DEFAULTS;