bdy 1.18.33-dev → 1.18.33-dev-pipeline

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.18.33-dev",
+  "version": "1.18.33-dev-pipeline",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {

package/distTs/src/api/client.js

@@ -216,6 +216,37 @@ class ApiClient {
             throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
         }
     }
+    async getPipelineRunActionLogs(workspace, project, pipelineId, executionId, actionExecutionId, offset, limit) {
+        const query = {
+            offset: String(offset),
+            limit: String(limit),
+        };
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions/${encodeURIComponent(executionId)}/action_executions/${encodeURIComponent(actionExecutionId)}/logs`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async getPipelineRunActionExecution(workspace, project, pipelineId, executionId, actionExecutionId) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions/${encodeURIComponent(executionId)}/action_executions/${encodeURIComponent(actionExecutionId)}`,
+            parseResponseBody: true,
+        });
+    }
+    async getPipelineRuns(workspace, project, pipelineId, page = 1, perPage = 10) {
+        const query = {
+            page: String(page),
+            per_page: String(perPage),
+        };
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions`,
+            query,
+            parseResponseBody: true,
+        });
+    }
     async getPipelineRun(workspace, project, pipelineId, executionId) {
         return await this.request({
             method: 'GET',
@@ -256,6 +287,34 @@ class ApiClient {
             parseResponseBody: true,
         });
     }
+    async pipelineRunRetry(workspace, project, pipelineId, runId) {
+        return await this.request({
+            method: 'PATCH',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions/${encodeURIComponent(runId)}`,
+            body: {
+                operation: 'RETRY',
+            },
+            parseResponseBody: true,
+        });
+    }
+    async pipelineRunApply(workspace, project, pipelineId, runId, body) {
+        return await this.request({
+            method: 'PATCH',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions/${encodeURIComponent(runId)}`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async pipelineRunCancel(workspace, project, pipelineId, runId) {
+        return await this.request({
+            method: 'PATCH',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions/${encodeURIComponent(runId)}`,
+            body: {
+                operation: 'CANCEL',
+            },
+            parseResponseBody: true,
+        });
+    }
     async pipelineRun(workspace, project, pipelineId, body) {
         return await this.request({
             method: 'POST',
@@ -721,14 +780,14 @@ class ApiClient {
         return await this.request({
             method: 'POST',
             path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/apps/${encodeURIComponent(appId)}/stop`,
-            parseResponseBody: true
+            parseResponseBody: true,
         });
     }
     async startSandboxApp(workspace, sandboxId, appId) {
         return await this.request({
             method: 'POST',
             path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/apps/${encodeURIComponent(appId)}/start`,
-            parseResponseBody: true
+            parseResponseBody: true,
         });
     }
     async getSandboxAppLogs(workspace, sandboxId, appId, cursor) {

package/distTs/src/command/crawl/link.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const output_1 = __importDefault(require("../../output"));
+const commandCrawlLink = (0, utils_1.newCommand)('link', texts_1.DESC_COMMAND_CRAWL_LINK);
+commandCrawlLink.option('-w, --workspace <workspace>', texts_1.OPTION_REST_API_WORKSPACE);
+commandCrawlLink.option('-p, --project <project>', texts_1.OPTION_REST_API_PROJECT);
+commandCrawlLink.option('-s, --suite <suite>', texts_1.OPTION_SUITE_IDENTIFIER);
+commandCrawlLink.action(async (options) => {
+    const Input = require('../../input').default;
+    const ProjectCfg = require('../../project/cfg').default;
+    output_1.default.handleSignals();
+    const workspace = Input.restApiWorkspace(options.workspace);
+    const project = Input.restApiProject(options.project);
+    const client = Input.restApiTokenClient(false, options.api, options.region);
+    let suiteIdentifier = options.suite;
+    if (!suiteIdentifier) {
+        const opt = await output_1.default.inputMenuAdv(texts_1.TXT_COMMAND_SUITE_SELECT, [
+            {
+                name: texts_1.TXT_COMMAND_SUITE_CREATE_NEW,
+                description: texts_1.TXT_COMMAND_SUITE_CREATE_NEW_CRAWL_DESC,
+                value: 'new',
+            },
+            {
+                name: texts_1.TXT_COMMAND_SUITE_LINK_EXISTING,
+                description: texts_1.TXT_COMMAND_SUITE_LINK_EXISTING_DESC,
+                value: 'existing',
+            },
+        ]);
+        if (opt === 'new') {
+            const name = await output_1.default.inputString(texts_1.TXT_COMMAND_SUITE_NAME);
+            const response = await client.createCrawlSuite(workspace, project, { name, identifier: name });
+            output_1.default.okSign();
+            output_1.default.normal(texts_1.TXT_COMMAND_SUITE_CREATED);
+            suiteIdentifier = response.identifier;
+        }
+        else {
+            const result = await client.getCrawlSuites(workspace, project);
+            const suites = result?.suites || [];
+            if (!suites.length) {
+                output_1.default.exitError(texts_1.ERR_NO_CRAWL_SUITES);
+            }
+            if (suites.length === 1) {
+                suiteIdentifier = suites[0].identifier;
+            }
+            else {
+                const items = suites.map((s) => s.name || s.identifier);
+                const index = await output_1.default.inputMenu(texts_1.TXT_COMMAND_CRAWL_LINK_SELECT, items);
+                suiteIdentifier = suites[index].identifier;
+            }
+        }
+    }
+    ProjectCfg.setSuite((0, utils_1.getWorkingDir)(), 'crawl', suiteIdentifier);
+    output_1.default.okSign();
+    output_1.default.exitSuccess(texts_1.TXT_COMMAND_CRAWL_LINK_SUCCESS);
+});
+exports.default = commandCrawlLink;

package/distTs/src/command/crawl/run.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const commander_1 = require("commander");
+const texts_1 = require("../../texts");
+const output_1 = __importDefault(require("../../output"));
+const node_zlib_1 = require("node:zlib");
+const promises_1 = require("node:stream/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const promises_2 = require("node:fs/promises");
+const commandCrawlRun = (0, utils_1.newCommand)('run', texts_1.DESC_COMMAND_CRAWL_RUN);
+commandCrawlRun.argument('[url]', texts_1.OPTION_CRAWL_URL);
+commandCrawlRun.option('--follow', texts_1.OPTION_CRAWL_FOLLOW, false);
+commandCrawlRun.option('--respectRobots', texts_1.OPTION_COMPARE_RESPECT_ROBOTS, false);
+commandCrawlRun.addOption(new commander_1.Option('--outputType <type>', texts_1.OPTION_CRAWL_OUTPUT_TYPE).choices([
+    'jpeg',
+    'png',
+    'md',
+    'html',
+]));
+commandCrawlRun.option('--outputTypes <json>', texts_1.OPTION_CRAWL_OUTPUT_TYPES);
+commandCrawlRun.option('--quality <quality>', texts_1.OPTION_CRAWL_QUALITY);
+commandCrawlRun.option('--fullPage', texts_1.OPTION_CRAWL_FULL_PAGE, false);
+commandCrawlRun.option('--cssSelector <selector>', texts_1.OPTION_CRAWL_CSS_SELECTOR);
+commandCrawlRun.option('--xpathSelector <selector>', texts_1.OPTION_CRAWL_XPATH_SELECTOR);
+commandCrawlRun.addOption(new commander_1.Option('--colorScheme <scheme>', texts_1.OPTION_CRAWL_COLOR_SCHEME).choices([
+    'LIGHT',
+    'DARK',
+    'LIGHT_AND_DARK',
+]));
+commandCrawlRun.option('--browsers <browsers>', texts_1.OPTION_CRAWL_BROWSERS);
+commandCrawlRun.option('--devices <devices>', texts_1.OPTION_CRAWL_DEVICES);
+commandCrawlRun.option('--waitFor <waitFors...>', texts_1.OPTION_COMPARE_WAIT_FOR);
+commandCrawlRun.option('--cookie <cookies...>', texts_1.OPTION_COMPARE_COOKIE);
+commandCrawlRun.option('--header <headers...>', texts_1.OPTION_COMPARE_HEADER);
+commandCrawlRun.option('--localStorage <items...>', texts_1.OPTION_CRAWL_LOCAL_STORAGE);
+commandCrawlRun.option('--delay <delays...>', texts_1.OPTION_CRAWL_DELAY);
+commandCrawlRun.option('--outputDir <dir>', texts_1.OPTION_CRAWL_OUTPUT_DIR, '.');
+commandCrawlRun.action(async (inputUrl, options) => {
+    const { downloadCrawlPackage, sendCrawl } = require('../../crawl/requests');
+    const { createCrawlContext, applyToken, applyCiAndCommitInfo } = require('../../visualTest/context');
+    const { validateInputAndOptions } = require('./validation');
+    const { getCiAndGitInfo } = require('@buddy-works/ci-info');
+    const tar = require('tar-stream');
+    const Input = require('../../input').default;
+    const token = await Input.crawlSuiteToken();
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_MISSING_CRAWL_TOKEN);
+    }
+    const ctx = createCrawlContext();
+    applyToken(ctx, token);
+    const { url, follow, respectRobots, outputTypes, outputDir, colorScheme, browsers, devices, cookies, requestHeaders, delays, waitForSelectors, localStorage, } = validateInputAndOptions(inputUrl, options);
+    try {
+        const ciAndGitInfo = await getCiAndGitInfo({});
+        applyCiAndCommitInfo(ctx, ciAndGitInfo);
+        const { buildId } = await sendCrawl(ctx, url, follow, respectRobots, outputTypes, colorScheme, browsers, devices, cookies, requestHeaders, delays, waitForSelectors, localStorage);
+        const status = await watchSessionStatus(ctx, buildId);
+        if (!status.ok) {
+            output_1.default.exitError(`Crawl session failed: ${status.error}`);
+        }
+        output_1.default.normal('Downloading crawl package');
+        const crawlPackageStream = await downloadCrawlPackage(ctx, buildId);
+        const brotliDecompressor = (0, node_zlib_1.createBrotliDecompress)();
+        const unpack = tar.extract();
+        unpack.on('entry', async (header, stream, next) => {
+            const currentDir = process.cwd();
+            const preparedOutputDir = outputDir.startsWith('.')
+                ? node_path_1.default.join(currentDir, outputDir)
+                : outputDir;
+            const newFilePath = node_path_1.default.join(preparedOutputDir, header.name);
+            try {
+                if (header.type === 'file') {
+                    await (0, promises_2.mkdir)(node_path_1.default.dirname(newFilePath), { recursive: true });
+                    const fileWriteStream = (0, node_fs_1.createWriteStream)(newFilePath);
+                    await (0, promises_1.pipeline)(stream, fileWriteStream);
+                    next();
+                }
+                else {
+                    stream.resume();
+                    next();
+                }
+            }
+            catch (entryError) {
+                output_1.default.error(`Error processing entry ${header.name}: ${entryError}`);
+                next(entryError);
+            }
+        });
+        await (0, promises_1.pipeline)(crawlPackageStream, brotliDecompressor, unpack);
+        output_1.default.exitSuccess('Downloading crawl package finished');
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+async function watchSessionStatus(ctx, buildId) {
+    const { connectToCrawlSession } = require('../../crawl/requests');
+    return new Promise((resolve) => {
+        const eventSource = connectToCrawlSession(ctx, buildId);
+        eventSource.addEventListener('SESSION_STATUS', (event) => {
+            const data = JSON.parse(event.data);
+            if (data.status === 'STARTED') {
+                output_1.default.normal('Crawl session started');
+            }
+            else if (data.status === 'GATHER_URLS_COMPLETED') {
+                output_1.default.normal(`Gathering URLs completed, found ${data.text} URLs`);
+            }
+            else if (data.status === 'GATHER_URLS_FAILED') {
+                output_1.default.error('Gathering URLs failed');
+            }
+            else if (data.status === 'CRAWL_URL_COMPLETED') {
+                output_1.default.normal(`Crawling ${data.text} completed`);
+            }
+            else if (data.status === 'CRAWL_URL_FAILED') {
+                output_1.default.error(`Crawling ${data.text} failed`);
+            }
+            else if (data.status === 'CREATE_PACKAGE_COMPLETED') {
+                output_1.default.normal('Package created');
+            }
+            else if (data.status === 'CREATE_PACKAGE_FAILED') {
+                output_1.default.error('Package creation failed');
+            }
+            else if (data.status === 'ERROR') {
+                eventSource.close();
+                resolve({ ok: false, error: data.text });
+            }
+            else if (data.status === 'FINISHED') {
+                eventSource.close();
+                output_1.default.normal('Crawl session finished');
+                resolve({ ok: true });
+            }
+        });
+        eventSource.addEventListener('error', (event) => {
+            if (event.code) {
+                eventSource.close();
+                if (event.code === 410) {
+                    output_1.default.normal('Crawl session finished');
+                }
+                resolve({ ok: event.code === 410, error: event.code });
+            }
+        });
+    });
+}
+exports.default = commandCrawlRun;

package/distTs/src/command/crawl/validation.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInputAndOptions = validateInputAndOptions;
+const zod_1 = require("zod");
+const output_1 = __importDefault(require("../../output"));
+const validation_1 = require("../tests/visual/shared/validation");
+const urlSchema = zod_1.z.string().url().optional();
+const browserSchema = zod_1.z.enum(['chrome', 'firefox', 'safari']);
+const browsersListSchema = zod_1.z
+    .string()
+    .transform((value) => value
+    .split(',')
+    .map((browser) => browser.trim().toLowerCase())
+    .filter((browser) => browser.length > 0))
+    .refine((browsers) => browsers.length > 0, {
+    message: 'Invalid browsers list. Supported values: chrome,firefox,safari',
+})
+    .pipe(zod_1.z.array(browserSchema))
+    .transform((browsers) => Array.from(new Set(browsers.map((browser) => browser === 'chrome'
+    ? 'CHROMIUM'
+    : browser === 'firefox'
+        ? 'FIREFOX'
+        : 'WEBKIT'))));
+const optionsSchema = zod_1.z.object({
+    follow: zod_1.z.boolean(),
+    respectRobots: zod_1.z.boolean().optional(),
+    outputType: zod_1.z.enum(['jpeg', 'png', 'md', 'html']).optional(),
+    outputTypes: zod_1.z.string().optional(),
+    quality: zod_1.z.coerce.number().min(1).max(100).optional(),
+    outputDir: zod_1.z.string().default('.'),
+    fullPage: zod_1.z.boolean().optional(),
+    cssSelector: zod_1.z.string().optional(),
+    xpathSelector: zod_1.z.string().optional(),
+    colorScheme: zod_1.z.enum(['LIGHT', 'DARK', 'LIGHT_AND_DARK']).optional(),
+    browsers: browsersListSchema.optional(),
+    devices: zod_1.z.string().optional(),
+    delay: validation_1.delaySchema,
+    waitFor: validation_1.waitForSchema,
+    cookie: validation_1.cookieSchema,
+    header: validation_1.headerSchema,
+    localStorage: zod_1.z
+        .array(zod_1.z.string().regex(/^(?:([^:]+)::)?([^=]+)=(.*)$/, {
+        message: "LocalStorage option must follow pattern '[scope::]key=value' (scope is optional)",
+    }))
+        .optional()
+        .transform((value) => value?.map((v) => {
+        const { scope, key, value } = (0, validation_1.parseScopedKeyValue)(v);
+        return { scope, key, value };
+    })),
+});
+function validateInputAndOptions(input, options) {
+    try {
+        const url = urlSchema.parse(input);
+        const { follow, respectRobots, outputType, outputTypes: rawOutputTypes, quality, outputDir, fullPage, cssSelector, xpathSelector, colorScheme, browsers: parsedBrowsers, devices: rawDevices, delay, waitFor, cookie, header, localStorage, } = optionsSchema.parse(options);
+        let parsedOutputTypes;
+        if (rawOutputTypes) {
+            try {
+                const outputTypeEntrySchema = zod_1.z.array(zod_1.z
+                    .object({
+                    type: zod_1.z.string().transform((v) => v.toUpperCase()),
+                    selector: zod_1.z
+                        .object({
+                        type: zod_1.z.enum(['CSS', 'XPATH']).optional(),
+                        value: zod_1.z.string().optional(),
+                    })
+                        .optional(),
+                    quality: zod_1.z.number().min(1).max(100).optional(),
+                    fullPage: zod_1.z.boolean().optional(),
+                })
+                    .transform((data) => ({
+                    ...data,
+                    type: data.type,
+                })));
+                parsedOutputTypes = outputTypeEntrySchema.parse(JSON.parse(rawOutputTypes));
+            }
+            catch {
+                output_1.default.exitError("Invalid --outputTypes value. Use JSON array, e.g. --outputTypes '[{\"type\":\"png\"},{\"type\":\"jpeg\",\"quality\":80}]'");
+            }
+        }
+        else if (outputType) {
+            if (typeof quality === 'number' && outputType !== 'jpeg') {
+                output_1.default.exitError('Quality is only supported for jpeg output type, use --outputType jpeg');
+            }
+            if (cssSelector && xpathSelector) {
+                output_1.default.exitError('Only one of --cssSelector or --xpathSelector can be used');
+            }
+            const entry = {
+                type: outputType.toUpperCase(),
+            };
+            if (cssSelector) {
+                entry.selector = { type: 'CSS', value: cssSelector };
+            }
+            else if (xpathSelector) {
+                entry.selector = { type: 'XPATH', value: xpathSelector };
+            }
+            if (typeof quality === 'number') {
+                entry.quality = quality;
+            }
+            if (fullPage) {
+                entry.fullPage = fullPage;
+            }
+            parsedOutputTypes = [entry];
+        }
+        let parsedDevices;
+        if (rawDevices) {
+            try {
+                const dimensionSchema = zod_1.z
+                    .string()
+                    .regex(/^\d+x\d+$/, 'Must be in format "widthxheight"')
+                    .transform((val) => {
+                    const [width, height] = val.split('x').map(Number);
+                    return { width, height };
+                });
+                const deviceSchema = zod_1.z.array(zod_1.z.object({
+                    name: zod_1.z.string().optional(),
+                    viewport: dimensionSchema,
+                    screen: dimensionSchema,
+                    devicePixelRatio: zod_1.z.number().positive(),
+                    isMobile: zod_1.z.boolean(),
+                }));
+                parsedDevices = deviceSchema.parse(JSON.parse(rawDevices));
+            }
+            catch {
+                output_1.default.exitError('Invalid --devices value. Use JSON array, e.g. --devices \'[{"viewport":"1920x1080","screen":"1920x1080","devicePixelRatio":1,"isMobile":false}]\'');
+            }
+        }
+        return {
+            url,
+            follow,
+            respectRobots,
+            outputTypes: parsedOutputTypes,
+            outputDir,
+            colorScheme,
+            browsers: parsedBrowsers,
+            devices: parsedDevices,
+            cookies: cookie,
+            requestHeaders: header,
+            delays: delay ?? [],
+            waitForSelectors: waitFor,
+            localStorage,
+        };
+    }
+    catch (error) {
+        if (error instanceof zod_1.ZodError) {
+            output_1.default.exitError(error.errors.map((e) => `${e.path}: ${e.message}`).join(', '));
+        }
+        else {
+            throw error;
+        }
+    }
+}

package/distTs/src/command/crawl.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const texts_1 = require("../texts");
+const run_1 = __importDefault(require("./crawl/run"));
+const link_1 = __importDefault(require("./crawl/link"));
+const commandCrawl = (0, utils_1.newCommand)('crawl', texts_1.DESC_COMMAND_CRAWL);
+commandCrawl.addCommand(run_1.default);
+commandCrawl.addCommand(link_1.default);
+exports.default = commandCrawl;

package/distTs/src/command/pipeline/run/apply.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const input_1 = __importDefault(require("../../../input"));
+const output_1 = __importDefault(require("../../../output"));
+const pipeline_1 = require("../../../types/pipeline");
+const commandPipelineRunApply = (0, utils_1.newCommand)('apply', texts_1.DESC_COMMAND_PIPELINE_RUN_APPLY);
+commandPipelineRunApply.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPipelineRunApply.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPipelineRunApply.option('-n, --no-wait', texts_1.OPTION_PIPELINE_RUN_NO_WAIT);
+commandPipelineRunApply.argument('<identifier>', texts_1.OPTION_PIPELINE_RUN_ARGUMENT);
+commandPipelineRunApply.argument('<run-id>', texts_1.OPTION_PIPELINE_RUN_ID);
+commandPipelineRunApply.argument('<run-action-id>', texts_1.OPTION_PIPELINE_RUN_ACTION_ID);
+commandPipelineRunApply.option('-v,--variable <variables...>', texts_1.OPTION_PIPELINE_RUN_VAR);
+commandPipelineRunApply.addHelpText('after', texts_1.EXAMPLE_PIPELINE_RUN_APPLY);
+commandPipelineRunApply.action(async (identifier, runId, runActionId, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const rid = input_1.default.pipelineRunId(runId);
+    const variables = input_1.default.pipelineRunVariable(options.variable || [], false);
+    const client = input_1.default.restApiTokenClient();
+    const data = await client.getPipelineByIdentifier(workspace, project, identifier);
+    if (!data || !data.domain) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
+    }
+    if (!data.project_identifier) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NOT_FOUND);
+    }
+    if (!data.pipeline_id) {
+        output_1.default.exitError(texts_1.ERR_PIPELINE_NOT_FOUND);
+    }
+    const a = await client.getPipelineRunActionExecution(workspace, project, data.pipeline_id, rid, runActionId);
+    let type;
+    if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_APPLY) {
+        type = 'APPLY';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VT_SESSION) {
+        type = 'APPROVE_VT';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VARIABLES) {
+        type = 'APPLY_VARIABLES';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_SETTABLE_VARIABLES) {
+        type = 'SET_VARIABLES';
+    }
+    else {
+        output_1.default.exitError(texts_1.ERR_CANT_APPLY_ACTION_EXECUTION);
+    }
+    const body = {
+        operation: type,
+        approve_action_id: runActionId,
+        variables,
+    };
+    await client.pipelineRunApply(workspace, project, data.pipeline_id, rid, body);
+    const OutputPipeline = require('../../../output/pipeline').default;
+    await OutputPipeline.runStatus(client, workspace, project, data.pipeline_id, rid, !options.wait);
+});
+exports.default = commandPipelineRunApply;

package/distTs/src/command/pipeline/run/cancel.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const input_1 = __importDefault(require("../../../input"));
+const output_1 = __importDefault(require("../../../output"));
+const commandPipelineRunCancel = (0, utils_1.newCommand)('cancel', texts_1.DESC_COMMAND_PIPELINE_RUN_CANCEL);
+commandPipelineRunCancel.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPipelineRunCancel.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPipelineRunCancel.option('-n, --no-wait', texts_1.OPTION_PIPELINE_RUN_NO_WAIT);
+commandPipelineRunCancel.argument('<identifier>', texts_1.OPTION_PIPELINE_RUN_ARGUMENT);
+commandPipelineRunCancel.argument('<run-id>', texts_1.OPTION_PIPELINE_RUN_ID);
+commandPipelineRunCancel.addHelpText('after', texts_1.EXAMPLE_PIPELINE_RUN_CANCEL);
+commandPipelineRunCancel.action(async (identifier, runId, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = input_1.default.restApiTokenClient();
+    const rid = input_1.default.pipelineRunId(runId);
+    const data = await client.getPipelineByIdentifier(workspace, project, identifier);
+    if (!data || !data.domain) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
+    }
+    if (!data.project_identifier) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NOT_FOUND);
+    }
+    if (!data.pipeline_id) {
+        output_1.default.exitError(texts_1.ERR_PIPELINE_NOT_FOUND);
+    }
+    await client.pipelineRunCancel(workspace, project, data.pipeline_id, rid);
+    const OutputPipeline = require('../../../output/pipeline').default;
+    await OutputPipeline.runStatus(client, workspace, project, data.pipeline_id, rid, !options.wait);
+});
+exports.default = commandPipelineRunCancel;

package/distTs/src/command/pipeline/run/list.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const input_1 = __importDefault(require("../../../input"));
+const output_1 = __importDefault(require("../../../output"));
+const commandPipelineRunList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_PIPELINE_RUN_LIST);
+commandPipelineRunList.alias('ls');
+commandPipelineRunList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPipelineRunList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPipelineRunList.option('--page <number>', texts_1.OPTION_REST_API_PAGE, '1');
+commandPipelineRunList.option('--per-page <number>', texts_1.OPTION_REST_API_PER_PAGE, '10');
+commandPipelineRunList.argument('<identifier>', texts_1.OPTION_PIPELINE_RUN_ARGUMENT);
+commandPipelineRunList.addHelpText('after', texts_1.EXAMPLE_PIPELINE_RUN_LIST);
+commandPipelineRunList.action(async (identifier, options) => {
+    const page = input_1.default.restApiPage(options.page);
+    const perPage = input_1.default.restApiPerPage(options.perPage);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = input_1.default.restApiTokenClient();
+    const data = await client.getPipelineByIdentifier(workspace, project, identifier);
+    if (!data || !data.domain) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
+    }
+    if (!data.project_identifier) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NOT_FOUND);
+    }
+    if (!data.pipeline_id) {
+        output_1.default.exitError(texts_1.ERR_PIPELINE_NOT_FOUND);
+    }
+    const result = await client.getPipelineRuns(workspace, project, data.pipeline_id, page, perPage);
+    if (!result.executions.length) {
+        output_1.default.exitError(texts_1.ERR_PIPELINE_RUNS_NOT_FOUND);
+    }
+    const OutputPipeline = require('../../../output/pipeline').default;
+    const table = [['ID', 'STATUS', 'STARTED', 'FINISHED', 'URL']];
+    for (const run of result.executions) {
+        table.push([
+            String(run.id),
+            OutputPipeline.runStatusText(run.status),
+            run.start_date || '-',
+            run.finish_date || '-',
+            run.html_url,
+        ]);
+    }
+    output_1.default.table(table);
+    output_1.default.exitNormal('');
+});
+exports.default = commandPipelineRunList;