bdy 1.18.8-dev → 1.18.9-dev-commands-changes-869c3r8yn

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.18.8-dev",
+  "version": "1.18.9-dev-commands-changes-869c3r8yn",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {

package/distTs/src/command/api/request.js

@@ -77,12 +77,34 @@ const prepareMultipartBody = async (params) => {
     }
     return form;
 };
+const parseUrl = (url) => {
+    const query = {};
+    let path = url;
+    let host = '';
+    try {
+        const u = new URL(url, 'https://example.com');
+        if (u.host !== 'example.com')
+            host = u.host;
+        path = decodeURIComponent(u.pathname);
+        u.searchParams.forEach((v, k) => {
+            query[k] = v;
+        });
+    }
+    catch {
+        // do nothing
+    }
+    return {
+        host,
+        path,
+        query,
+    };
+};
 const request = async (method, url, options) => {
     output_1.default.handleSignals();
+    const { query, path, host } = parseUrl(url);
     const workspace = input_1.default.restApiWorkspace(options.workspace, true);
     const project = input_1.default.restApiProject(options.project, true);
-    const client = input_1.default.restApiTokenClient();
-    const query = {};
+    const client = input_1.default.restApiTokenClient(false, host);
     if (options.query) {
         options.query.forEach((q) => {
             const s = q.split(':');
@@ -92,7 +114,7 @@ const request = async (method, url, options) => {
             query[s[0]] = s[1];
         });
     }
-    let preparedUrl = url;
+    let preparedUrl = path;
     if (workspace) {
         preparedUrl = preparedUrl.replaceAll('{workspace_domain}', encodeURIComponent(workspace));
     }

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

@@ -0,0 +1,151 @@
+"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(),
+    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: zod_1.z.coerce.number().min(0).max(10000),
+    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(),
+                })
+                    .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;
+            }
+            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,
+            fullPage,
+            colorScheme,
+            browsers: parsedBrowsers,
+            devices: parsedDevices,
+            cookies: cookie,
+            requestHeaders: header,
+            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,144 @@
+"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 commandCrawl = (0, utils_1.newCommand)('crawl', texts_1.DESC_COMMAND_CRAWL);
+commandCrawl.argument('[url]', texts_1.OPTION_CRAWL_URL);
+commandCrawl.option('--follow', texts_1.OPTION_CRAWL_FOLLOW, false);
+commandCrawl.option('--respectRobots', texts_1.OPTION_COMPARE_RESPECT_ROBOTS, false);
+commandCrawl.addOption(new commander_1.Option('--outputType <type>', texts_1.OPTION_CRAWL_OUTPUT_TYPE).choices([
+    'jpeg',
+    'png',
+    'md',
+    'html',
+]));
+commandCrawl.option('--outputTypes <json>', texts_1.OPTION_CRAWL_OUTPUT_TYPES);
+commandCrawl.option('--quality <quality>', texts_1.OPTION_CRAWL_QUALITY);
+commandCrawl.option('--fullPage', texts_1.OPTION_CRAWL_FULL_PAGE, false);
+commandCrawl.option('--cssSelector <selector>', texts_1.OPTION_CRAWL_CSS_SELECTOR);
+commandCrawl.option('--xpathSelector <selector>', texts_1.OPTION_CRAWL_XPATH_SELECTOR);
+commandCrawl.addOption(new commander_1.Option('--colorScheme <scheme>', texts_1.OPTION_CRAWL_COLOR_SCHEME).choices([
+    'LIGHT',
+    'DARK',
+    'LIGHT_AND_DARK',
+]));
+commandCrawl.option('--browsers <browsers>', texts_1.OPTION_CRAWL_BROWSERS);
+commandCrawl.option('--devices <devices>', texts_1.OPTION_CRAWL_DEVICES);
+commandCrawl.option('--waitFor <waitFors...>', texts_1.OPTION_COMPARE_WAIT_FOR);
+commandCrawl.option('--cookie <cookies...>', texts_1.OPTION_COMPARE_COOKIE);
+commandCrawl.option('--header <headers...>', texts_1.OPTION_COMPARE_HEADER);
+commandCrawl.option('--localStorage <items...>', texts_1.OPTION_CRAWL_LOCAL_STORAGE);
+commandCrawl.option('--delay <delay>', texts_1.OPTION_CRAWL_DELAY, '0');
+commandCrawl.option('--outputDir <dir>', texts_1.OPTION_CRAWL_OUTPUT_DIR, '.');
+commandCrawl.action(async (inputUrl, options) => {
+    const { checkToken } = require('../visualTest/validation');
+    const { downloadScrapPackage, sendScrap } = require('../visualTest/requests');
+    const { setCiAndCommitInfo } = require('../visualTest/context');
+    const { validateInputAndOptions } = require('./crawl/validation');
+    const { getCiAndGitInfo } = require('@buddy-works/ci-info');
+    const tar = require('tar-stream');
+    if (!checkToken('scrape')) {
+        output_1.default.exitError(texts_1.ERR_MISSING_CRAWL_TOKEN);
+    }
+    const { url, follow, respectRobots, outputTypes, outputDir, fullPage, colorScheme, browsers, devices, cookies, requestHeaders, delay, waitForSelectors, localStorage, } = validateInputAndOptions(inputUrl, options);
+    try {
+        const ciAndGitInfo = await getCiAndGitInfo({});
+        setCiAndCommitInfo(ciAndGitInfo);
+        const { buildId } = await sendScrap(url, follow, respectRobots, outputTypes, fullPage, colorScheme, browsers, devices, cookies, requestHeaders, delay, waitForSelectors, localStorage);
+        const status = await watchSessionStatus(buildId);
+        if (!status.ok) {
+            output_1.default.exitError(`Crawl session failed: ${status.error}`);
+        }
+        output_1.default.normal('Downloading crawl package');
+        const scrapPackageStream = await downloadScrapPackage(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)(scrapPackageStream, brotliDecompressor, unpack);
+        output_1.default.exitSuccess('Downloading crawl package finished');
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+async function watchSessionStatus(buildId) {
+    const { connectToScrapSession } = require('../visualTest/requests');
+    return new Promise((resolve) => {
+        const eventSource = connectToScrapSession(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 === 'SCRAPE_URL_COMPLETED') {
+                output_1.default.normal(`Crawling ${data.text} completed`);
+            }
+            else if (data.status === 'SCRAPE_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 = commandCrawl;

package/distTs/src/command/login.js

@@ -40,8 +40,7 @@ async function oauthServer(api, clientId, clientSecret) {
             const urlCode = url.searchParams.get('code');
             if (!urlCode) {
                 res.end(texts_1.ERR_LOGIN_HTTP_FAILED);
-                s.close();
-                output_1.default.exitError(texts_1.ERR_LOGIN_HTTP_FAILED);
+                return;
             }
             const client = new ApiClient(new URL(`https://${api}`));
             try {

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

@@ -103,24 +103,30 @@ function validateInputAndOptions(input, options) {
         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(),
-                }));
+                const viewportSchema = zod_1.z
+                    .object({
+                    width: zod_1.z.number().positive(),
+                    height: zod_1.z.number().positive(),
+                })
+                    .strict();
+                const deviceSchema = zod_1.z.array(zod_1.z
+                    .object({
+                    viewport: viewportSchema,
+                    screen: viewportSchema.optional(),
+                    devicePixelRatio: zod_1.z.number().positive().optional(),
+                    isMobile: zod_1.z.boolean().optional(),
+                })
+                    .strict()
+                    .transform((data) => ({
+                    viewport: data.viewport,
+                    screen: data.screen ?? data.viewport,
+                    devicePixelRatio: data.devicePixelRatio ?? 1,
+                    isMobile: data.isMobile ?? false,
+                })));
                 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}]\'');
+                output_1.default.exitError('Invalid --devices value. Use JSON array, e.g. --devices \'[{"viewport":{"width":1920,"height":1080}}]\'');
             }
         }
         return {

package/distTs/src/command/scrape.js

@@ -6,12 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const commander_1 = require("commander");
 const texts_1 = require("../texts");
+const validation_1 = require("../visualTest/validation");
 const output_1 = __importDefault(require("../output"));
+const requests_1 = require("../visualTest/requests");
 const node_zlib_1 = require("node:zlib");
+const tar_stream_1 = __importDefault(require("tar-stream"));
 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 context_1 = require("../visualTest/context");
+const ci_info_1 = require("@buddy-works/ci-info");
+const validation_2 = require("./scrape/validation");
 const commandScrape = (0, utils_1.newCommand)('scrape', texts_1.DESC_COMMAND_VT_SCRAPE);
 commandScrape.argument('[url]', texts_1.OPTION_SCRAPE_URL);
 commandScrape.option('--follow', texts_1.OPTION_SCRAPE_FOLLOW, false);
@@ -41,28 +47,22 @@ commandScrape.option('--localStorage <items...>', texts_1.OPTION_SCRAPE_LOCAL_ST
 commandScrape.option('--delay <delay>', texts_1.OPTION_SCRAPE_DELAY, '0');
 commandScrape.option('--outputDir <dir>', texts_1.OPTION_SCRAPE_OUTPUT_DIR, '.');
 commandScrape.action(async (inputUrl, options) => {
-    const { checkToken } = require('../visualTest/validation');
-    const { downloadScrapPackage, sendScrap } = require('../visualTest/requests');
-    const { setCiAndCommitInfo } = require('../visualTest/context');
-    const { validateInputAndOptions } = require('./scrape/validation');
-    const { getCiAndGitInfo } = require('@buddy-works/ci-info');
-    const tar = require('tar-stream');
-    if (!checkToken('scrape')) {
+    if (!(0, validation_1.checkToken)('scrape')) {
         output_1.default.exitError(texts_1.ERR_MISSING_SCRAPE_TOKEN);
     }
-    const { url, follow, respectRobots, outputTypes, outputDir, fullPage, colorScheme, browsers, devices, cookies, requestHeaders, delay, waitForSelectors, localStorage, } = validateInputAndOptions(inputUrl, options);
+    const { url, follow, respectRobots, outputTypes, outputDir, fullPage, colorScheme, browsers, devices, cookies, requestHeaders, delay, waitForSelectors, localStorage, } = (0, validation_2.validateInputAndOptions)(inputUrl, options);
     try {
-        const ciAndGitInfo = await getCiAndGitInfo({});
-        setCiAndCommitInfo(ciAndGitInfo);
-        const { buildId } = await sendScrap(url, follow, respectRobots, outputTypes, fullPage, colorScheme, browsers, devices, cookies, requestHeaders, delay, waitForSelectors, localStorage);
+        const ciAndGitInfo = await (0, ci_info_1.getCiAndGitInfo)({});
+        (0, context_1.setCiAndCommitInfo)(ciAndGitInfo);
+        const { buildId } = await (0, requests_1.sendScrap)(url, follow, respectRobots, outputTypes, fullPage, colorScheme, browsers, devices, cookies, requestHeaders, delay, waitForSelectors, localStorage);
         const status = await watchSessionStatus(buildId);
         if (!status.ok) {
             output_1.default.exitError(`Scrape session failed: ${status.error}`);
         }
         output_1.default.normal('Downloading scrape package');
-        const scrapPackageStream = await downloadScrapPackage(buildId);
+        const scrapPackageStream = await (0, requests_1.downloadScrapPackage)(buildId);
         const brotliDecompressor = (0, node_zlib_1.createBrotliDecompress)();
-        const unpack = tar.extract();
+        const unpack = tar_stream_1.default.extract();
         unpack.on('entry', async (header, stream, next) => {
             const currentDir = process.cwd();
             const preparedOutputDir = outputDir.startsWith('.')
@@ -94,9 +94,8 @@ commandScrape.action(async (inputUrl, options) => {
     }
 });
 async function watchSessionStatus(buildId) {
-    const { connectToScrapSession } = require('../visualTest/requests');
     return new Promise((resolve) => {
-        const eventSource = connectToScrapSession(buildId);
+        const eventSource = (0, requests_1.connectToScrapSession)(buildId);
         eventSource.addEventListener('SESSION_STATUS', (event) => {
             const data = JSON.parse(event.data);
             if (data.status === 'STARTED') {

package/distTs/src/command/tests/capture/validation.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOptions = validateOptions;
+exports.checkIfMinimalOptionsAreProvided = checkIfMinimalOptionsAreProvided;
+const zod_1 = require("zod");
+const output_1 = __importDefault(require("../../../output"));
+const validation_1 = require("../visual/shared/validation");
+const optionsSchema = zod_1.z.object({
+    urls: zod_1.z.string().optional(),
+    sitemap: zod_1.z.string().optional(),
+    urlsFile: zod_1.z.string().optional(),
+    follow: zod_1.z.boolean(),
+    respectRobots: zod_1.z.boolean(),
+    ignore: zod_1.z
+        .array(zod_1.z.string().regex(/^(?:([^:]+)::)?(?:(CSS|XPATH))=(.+)$/, {
+        message: "Ignore option must follow pattern '[scope::]type=value' where type must be CSS or XPATH (scope is optional)",
+    }))
+        .optional()
+        .transform(validation_1.parseScopedSelector),
+    cookie: validation_1.cookieSchema,
+    header: validation_1.headerSchema,
+    delay: zod_1.z
+        .array(zod_1.z.string().regex(/^(?:([^:]+)::)?(\d+)$/, {
+        message: "Delay option must follow pattern '[scope::]milliseconds' (scope is optional)",
+    }))
+        .optional()
+        .transform((value) => value?.map((v) => {
+        if (v.includes('::')) {
+            const [scope, milliseconds] = v.split('::');
+            return { scope: scope.trim(), value: Number(milliseconds) };
+        }
+        else {
+            return { scope: validation_1.DEFAULT_SCOPE, value: Number(v) };
+        }
+    })),
+    waitFor: validation_1.waitForSchema,
+    ignoreUrls: zod_1.z.array(zod_1.z.string()).optional(),
+    dryRun: zod_1.z.boolean().optional(),
+});
+function validateOptions(options) {
+    try {
+        const validatedOptions = optionsSchema.parse(options);
+        return validatedOptions;
+    }
+    catch (error) {
+        if (error instanceof zod_1.ZodError) {
+            output_1.default.exitError(error.errors.map((e) => e.message).join(', '));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+function checkIfMinimalOptionsAreProvided(options) {
+    return !!options.urls || !!options.sitemap || !!options.urlsFile;
+}

package/distTs/src/command/tests/capture.js

@@ -0,0 +1,100 @@
+"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 node_fs_1 = require("node:fs");
+const commandCapture = (0, utils_1.newCommand)('capture', texts_1.DESC_COMMAND_CAPTURE);
+commandCapture.option('--urls <urls>', texts_1.OPTION_COMPARE_URLS);
+commandCapture.option('--sitemap <sitemap>', texts_1.OPTION_COMPARE_SITEMAP);
+commandCapture.option('--urlsFile <urlsFile>', texts_1.OPTION_COMPARE_URLS_FILE);
+commandCapture.option('--dryRun', texts_1.OPTION_COMPARE_DRY_RUN);
+commandCapture.option('--follow', texts_1.OPTION_COMPARE_FOLLOW, false);
+commandCapture.option('--respectRobots', texts_1.OPTION_COMPARE_RESPECT_ROBOTS, false);
+commandCapture.option('--ignoreUrls <ignoreUrls...>', texts_1.OPTION_COMPARE_IGNORE_URLS);
+commandCapture.option('--ignore <ignores...>', texts_1.OPTION_COMPARE_IGNORE);
+commandCapture.option('--cookie <cookies...>', texts_1.OPTION_COMPARE_COOKIE);
+commandCapture.option('--header <headers...>', texts_1.OPTION_COMPARE_HEADER);
+commandCapture.option('--delay <delays...>', texts_1.OPTION_COMPARE_DELAY);
+commandCapture.option('--waitFor <waitFors...>', texts_1.OPTION_COMPARE_WAIT_FOR);
+commandCapture.action(async (options) => {
+    const { getCiAndGitInfo, formattedCiInfo } = require('@buddy-works/ci-info');
+    const { checkToken } = require('../../visualTest/validation');
+    const { addProtocolIfMissing } = require('../../visualTest/linkUtils');
+    const { sendCompareLinks } = require('../../visualTest/requests');
+    const { checkIfMinimalOptionsAreProvided, validateOptions } = require('./capture/validation');
+    const { setCiAndCommitInfo } = require('../../visualTest/context');
+    const validatedOptions = validateOptions(options);
+    if (!checkToken('vt')) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    if (!checkIfMinimalOptionsAreProvided(validatedOptions)) {
+        output_1.default.exitError(texts_1.ERR_MISSING_URLS);
+    }
+    let urls = [];
+    let sitemapSource;
+    if (validatedOptions.urls) {
+        const urlsList = getUrlsFromUrlOption(validatedOptions.urls);
+        urls = urls.concat(urlsList);
+    }
+    if (validatedOptions.urlsFile) {
+        const urlsList = getUrlsFromUrlFile(validatedOptions.urlsFile);
+        urls = urls.concat(urlsList);
+    }
+    if (validatedOptions.sitemap) {
+        sitemapSource = addProtocolIfMissing(validatedOptions.sitemap);
+    }
+    const { filteredUrls, duplicates } = filterDuplicates(urls);
+    if (duplicates.length > 0) {
+        output_1.default.normal(`Detected ${duplicates.length} duplicated urls:`);
+        output_1.default.normal(duplicates.join('\n'));
+    }
+    if (validatedOptions.dryRun) {
+        output_1.default.exitSuccess(`List of urls:\n${filteredUrls.join('\n')}`);
+    }
+    else if (filteredUrls.length > 1) {
+        output_1.default.normal(`List of urls:\n${filteredUrls.join('\n')}`);
+    }
+    const ciAndGitInfo = await getCiAndGitInfo({});
+    output_1.default.normal(formattedCiInfo(ciAndGitInfo));
+    setCiAndCommitInfo(ciAndGitInfo);
+    try {
+        const { message } = await sendCompareLinks(filteredUrls, validatedOptions, sitemapSource);
+        output_1.default.exitSuccess(message);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+function getUrlsFromUrlOption(urls) {
+    const { addProtocolIfMissing } = require('../../visualTest/linkUtils');
+    return urls.split(',').map((url) => addProtocolIfMissing(url).trim());
+}
+function getUrlsFromUrlFile(urlsFile) {
+    const { addProtocolIfMissing } = require('../../visualTest/linkUtils');
+    const urlsFromFile = (0, node_fs_1.readFileSync)(urlsFile, 'utf-8');
+    return urlsFromFile
+        .split('\n')
+        .filter((url) => url.trim().length > 0)
+        .map((url) => addProtocolIfMissing(url).trim());
+}
+function filterDuplicates(urls) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const url of urls) {
+        if (seen.has(url)) {
+            duplicates.add(url);
+        }
+        else {
+            seen.add(url);
+        }
+    }
+    return {
+        filteredUrls: Array.from(seen),
+        duplicates: Array.from(duplicates),
+    };
+}
+exports.default = commandCapture;