bdy 1.17.29-dev → 1.18.0-dev-scrape-869b6rbvf

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.17.29-dev",
+  "version": "1.18.0-dev-scrape-869b6rbvf",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {

package/distTs/src/api/client.js

@@ -253,7 +253,7 @@ class ApiClient {
             method: 'POST',
             path: `/workspaces/${encodeURIComponent(workspace)}/projects`,
             body,
-            parseResponseBody: true
+            parseResponseBody: true,
         });
     }
     async pipelineRun(workspace, project, pipelineId, body) {
@@ -278,14 +278,14 @@ class ApiClient {
             method: 'POST',
             path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/yaml?project_name=${encodeURIComponent(project)}`,
             body,
-            parseResponseBody: true
+            parseResponseBody: true,
         });
     }
     async getSandboxYaml(workspace, sandboxId) {
         return await this.request({
             method: 'GET',
             path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/yaml`,
-            parseResponseBody: true
+            parseResponseBody: true,
         });
     }
     async updateSandboxByYaml(workspace, sandboxId, body) {
@@ -293,7 +293,7 @@ class ApiClient {
             method: 'PATCH',
             path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/yaml`,
             body,
-            parseResponseBody: true
+            parseResponseBody: true,
         });
     }
     async sandboxDownloadFile(workspace, sandboxId, remotePath) {
@@ -359,6 +359,70 @@ class ApiClient {
             parseResponseBody: true,
         });
     }
+    async domainBuy(workspace, name, onOwnerBehalf = false, autoRenew = true) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/domains/register`,
+            body: {
+                name,
+                on_owner_behalf: onOwnerBehalf,
+                auto_renew: autoRenew,
+            },
+        });
+    }
+    async domainClaim(workspace, name, onOwnerBehalf = false) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/domains/claim`,
+            body: {
+                name,
+                on_owner_behalf: onOwnerBehalf,
+            },
+        });
+    }
+    async domainSearch(workspace, domains) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/domains/search`,
+            body: { domains },
+            parseResponseBody: true,
+        });
+    }
+    async getDomains(workspace) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/domains`,
+            parseResponseBody: true,
+        });
+    }
+    async getDomain(workspace, id) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/domains/${encodeURIComponent(id)}`,
+            parseResponseBody: true,
+        });
+    }
+    async domainSuggest(workspace, prompt, tlds, limit) {
+        const body = {
+            prompt,
+            limit,
+        };
+        if (tlds.length > 0)
+            body.tlds = tlds;
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/domains/suggest`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async domainClaimable(workspace, name) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/domains/claimable/${encodeURIComponent(name)}`,
+            parseResponseBody: true,
+        });
+    }
     async registerApp(name, redirectUrl) {
         return await this.request({
             method: 'POST',
@@ -569,7 +633,7 @@ class ApiClient {
         return await this.request({
             method: 'GET',
             path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}`,
-            parseResponseBody: true
+            parseResponseBody: true,
         });
     }
     async getProjects(workspace, page = 1, perPage = 100) {
@@ -626,7 +690,7 @@ class ApiClient {
     async getSandboxByIdentifier(workspace, project, sandbox) {
         const opts = {
             project,
-            sandbox
+            sandbox,
         };
         return await this.getResourceByIdentifier(workspace, opts);
     }

package/distTs/src/command/domain/buy.js

@@ -0,0 +1,278 @@
+"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 input_1 = __importDefault(require("../../input"));
+const popularTlds = [
+    'com',
+    'ai',
+    'io',
+    'net',
+    'cloud',
+    'dev',
+    'app',
+    'info',
+    'blog',
+    'run',
+    'me',
+    'at',
+    'nl',
+    'xyz',
+    'org',
+    'co',
+    'tech',
+    'studio',
+    'sh',
+    'space',
+    'fyi',
+    'link',
+    'es',
+    'art',
+    'club',
+    'inc',
+    'pro',
+    'store',
+    'shop',
+    'one',
+    'biz',
+    'vip',
+    'tube',
+    'online',
+    'design',
+    'realty',
+    'audio',
+    'lol',
+    'pics',
+    'love',
+    'baby',
+    'lat',
+    'so',
+    'homes',
+    'beauty',
+    'buzz',
+    'mom',
+    'my',
+];
+const commandDomainBuy = (0, utils_1.newCommand)('buy', texts_1.DESC_COMMAND_DOMAIN_BUY);
+commandDomainBuy.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandDomainBuy.option('-d, --tld <tld...>', texts_1.OPT_COMMAND_DOMAIN_BUY_TLD);
+commandDomainBuy.option('-o, --owner-behalf', texts_1.OPT_COMMAND_DOMAIN_BUY_OWNER);
+commandDomainBuy.argument('[domain|prompt]', texts_1.OPT_COMMAND_DOMAIN_PHRASE);
+commandDomainBuy.action(async (text, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const tlds = getAllowedTlds(options.tld);
+    const prompt = (text || '').trim().toLowerCase();
+    const onOwnerBehalf = !!options.ownerBehalf;
+    if (output_1.default.isTTY()) {
+        await interactive(client, workspace, prompt, tlds, onOwnerBehalf);
+    }
+    else {
+        await nonInteractive(client, workspace, prompt, tlds, onOwnerBehalf);
+    }
+    output_1.default.exitNormal();
+});
+const formatDomainPrice = (price) => {
+    const sign = price.currency === 'USD' ? '$' : '€';
+    const value = price.price * price.min_duration;
+    const duration = price.min_duration === 1 ? '1yr' : `${price.min_duration}yrs`;
+    return `${sign}${value.toFixed(2)} (${duration})`;
+};
+const formatClaim = (domain, available) => {
+    if (available) {
+        return `${output_1.default.getGreenColor(domain)} (Free)`;
+    }
+    return output_1.default.getDimColor(`${domain} (Unavailable)`);
+};
+const formatDomain = (domain) => {
+    if (!domain.available || domain.premium) {
+        return output_1.default.getDimColor(`${domain.name} (Unavailable)`);
+    }
+    return `${output_1.default.getGreenColor(domain.name)} ${formatDomainPrice(domain.prices.create)} / ${formatDomainPrice(domain.prices.renew)}`;
+};
+const isValidDomain = (prompt) => {
+    return /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i.test(prompt);
+};
+const isValidSubdomain = (prompt) => {
+    return /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(prompt);
+};
+const getSubdomain = (domain) => {
+    const idx = domain.indexOf('.');
+    if (idx < 0)
+        return '';
+    return domain.substring(0, idx);
+};
+const getTld = (domain) => {
+    const idx = domain.lastIndexOf('.');
+    if (idx < 0)
+        return '';
+    return domain.substring(idx + 1);
+};
+const claimNonInteractive = async (client, workspace, domain, onOwnerBehalf) => {
+    output_1.default.arrowSign();
+    output_1.default.normal(`Matched: ${formatClaim(domain, true)}`);
+    await client.domainClaim(workspace, domain, onOwnerBehalf);
+    output_1.default.okSign();
+    output_1.default.normal(`${domain} claimed`);
+};
+const buyNonInteractive = async (client, workspace, domain, onOwnerBehalf) => {
+    output_1.default.arrowSign();
+    output_1.default.normal(`Matched: ${formatDomain(domain)}`);
+    if (domain.available && !domain.premium) {
+        await client.domainBuy(workspace, domain.name, onOwnerBehalf, true);
+        output_1.default.okSign();
+        output_1.default.normal(`${domain.name} bought`);
+    }
+};
+const interactive = async (client, workspace, prompt, tlds, onOwnerBehalf) => {
+    if (!prompt) {
+        prompt = await output_1.default.inputString(texts_1.TXT_COMMAND_DOMAIN_BUY_PROVIDE_PROMPT);
+    }
+    if (!prompt) {
+        output_1.default.exitError(texts_1.TXT_COMMAND_DOMAIN_BUY_PROMPT_REQUIRED);
+    }
+    output_1.default.arrowSign();
+    output_1.default.normal(`Searching...`);
+    let items = [];
+    const createValue = (type, name) => {
+        return `${type}:${name}`;
+    };
+    if (isValidDomain(prompt)) {
+        const subdomain = getSubdomain(prompt);
+        const claims = await client.domainClaimable(workspace, subdomain);
+        const claimable = claims.domains.find((c) => `${subdomain}.${c.domain}` === prompt);
+        if (claimable) {
+            items.push(output_1.default.createMenuSeparator('Matched'));
+            items.push(output_1.default.createMenuItem(formatClaim(prompt, claimable.available), createValue('claim', prompt)));
+        }
+        else {
+            const search = await client.domainSearch(workspace, [prompt]);
+            const buyable = search.domains.find((d) => d.name === prompt);
+            if (buyable) {
+                items.push(output_1.default.createMenuSeparator('Matched'));
+                items.push(output_1.default.createMenuItem(formatDomain(buyable), createValue('domain', prompt)));
+            }
+        }
+    }
+    else if (isValidSubdomain(prompt)) {
+        const claims = await client.domainClaimable(workspace, prompt);
+        const domains = [];
+        const searchTlds = tlds.length > 0 ? tlds : popularTlds;
+        searchTlds.forEach((tld) => {
+            domains.push(`${prompt}.${tld}`);
+        });
+        const search = await client.domainSearch(workspace, domains);
+        if (claims.domains.length > 0 || search.domains.length > 0) {
+            const claimsAvailable = claims.domains.filter((c) => (c.available && !tlds.length) || tlds.includes(c.domain));
+            const claimsUnavailable = claims.domains.filter((c) => (!c.available && !tlds.length) || tlds.includes(c.domain));
+            search.domains = search.domains.sort((a, b) => {
+                const aTld = getTld(a.name);
+                const bTld = getTld(b.name);
+                const aIdx = popularTlds.indexOf(aTld);
+                const bIdx = popularTlds.indexOf(bTld);
+                return aIdx < bIdx ? -1 : 1;
+            });
+            const domainsAvailable = search.domains.filter((d) => d.available && !d.premium);
+            const domainsUnavailable = search.domains.filter((d) => !d.available || d.premium);
+            domainsAvailable.forEach((d) => {
+                items.push(output_1.default.createMenuItem(formatDomain(d), createValue('domain', d.name)));
+            });
+            claimsAvailable.forEach((c, i) => {
+                const domain = `${prompt}.${c.domain}`;
+                const item = output_1.default.createMenuItem(formatClaim(domain, true), createValue('claim', domain));
+                if (i < 5)
+                    items.unshift(item);
+                else
+                    items.push(item);
+            });
+            domainsUnavailable.forEach((d) => {
+                items.push(output_1.default.createMenuItem(formatDomain(d), createValue('domain', d.name)));
+            });
+            claimsUnavailable.forEach((c) => {
+                const domain = `${prompt}.${c.domain}`;
+                const item = output_1.default.createMenuItem(formatClaim(domain, false), createValue('claim', domain));
+                items.push(item);
+            });
+            if (items.length > 10)
+                items = items.filter((_, i) => i < 10);
+            items.unshift(output_1.default.createMenuSeparator('Matched'));
+        }
+    }
+    const suggestions = await client.domainSuggest(workspace, prompt, tlds, 5);
+    if (suggestions.domains.length > 0 || suggestions.claims.length > 0) {
+        items.push(output_1.default.createMenuSeparator('Suggestions'));
+        let i = 0;
+        suggestions.claims.forEach((c) => {
+            if (i >= 10)
+                return;
+            items.push(output_1.default.createMenuItem(formatClaim(c, true), createValue('claim', c)));
+            i += 1;
+        });
+        suggestions.domains.forEach((d) => {
+            if (i >= 10)
+                return;
+            items.push(output_1.default.createMenuItem(formatDomain(d), createValue('domain', d.name)));
+            i += 1;
+        });
+    }
+    output_1.default.clearPreviousLine();
+    if (!items.length) {
+        output_1.default.exitError(texts_1.ERR_COMMAND_DOMAIN_NOT_FOUND);
+    }
+    const value = await output_1.default.inputMenuAdv(texts_1.TXT_COMMAND_DOMAIN_BUY_SELECT_DOMAIN, items);
+    const [type, name] = value.split(':');
+    if (type === 'claim') {
+        await client.domainClaim(workspace, name, onOwnerBehalf);
+        output_1.default.okSign();
+        output_1.default.normal(`${name} claimed`);
+    }
+    else {
+        await client.domainBuy(workspace, name, onOwnerBehalf);
+        output_1.default.okSign();
+        output_1.default.normal(`${name} bought`);
+    }
+};
+const nonInteractive = async (client, workspace, prompt, tlds, onOwnerBehalf) => {
+    if (!prompt) {
+        output_1.default.exitError(texts_1.TXT_COMMAND_DOMAIN_BUY_PROMPT_REQUIRED);
+    }
+    if (isValidDomain(prompt)) {
+        const subdomain = getSubdomain(prompt);
+        const claims = await client.domainClaimable(workspace, subdomain);
+        const claimable = claims.domains.find((c) => c.available && `${subdomain}.${c.domain}` === prompt);
+        if (claimable) {
+            await claimNonInteractive(client, workspace, prompt, onOwnerBehalf);
+            return;
+        }
+        const { domains } = await client.domainSearch(workspace, [prompt]);
+        await buyNonInteractive(client, workspace, domains[0], onOwnerBehalf);
+        return;
+    }
+    output_1.default.arrowSign();
+    output_1.default.normal(`Searching...`);
+    const suggestions = await client.domainSuggest(workspace, prompt, tlds, 5);
+    output_1.default.clearPreviousLine();
+    if (suggestions.claims.length > 0) {
+        await claimNonInteractive(client, workspace, suggestions.claims[0], onOwnerBehalf);
+        return;
+    }
+    if (suggestions.domains.length > 0) {
+        await buyNonInteractive(client, workspace, suggestions.domains[0], onOwnerBehalf);
+        return;
+    }
+    output_1.default.exitError(texts_1.ERR_COMMAND_DOMAIN_NOT_FOUND);
+};
+const getAllowedTlds = (tld) => {
+    const result = [];
+    if (tld) {
+        tld.forEach((t) => {
+            result.push(...t.split(',').map((t) => t.replace(/^\./, '')));
+        });
+    }
+    return result;
+};
+exports.default = commandDomainBuy;

package/distTs/src/command/domain/get.js

@@ -0,0 +1,45 @@
+"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 commandDomainGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_DOMAIN_GET);
+commandDomainGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandDomainGet.argument('<id|name>', texts_1.OPTION_COMMAND_DOMAIN_IDENTIFIER);
+commandDomainGet.action(async (name, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    let domain;
+    try {
+        domain = await client.getDomain(workspace, name);
+    }
+    catch {
+        const response = await client.getDomains(workspace);
+        domain = (response.domains || []).find((d) => d.name === name);
+        if (domain) {
+            domain = await client.getDomain(workspace, domain.id);
+        }
+    }
+    if (!domain) {
+        output_1.default.exitError(texts_1.ERR_COMMAND_DOMAIN_NOT_FOUND);
+    }
+    const props = {
+        Name: domain.name,
+        ID: domain.id,
+        Type: domain.type,
+    };
+    if (domain.type === 'REGISTERED') {
+        if (domain.expiry_date) {
+            props.Expires = domain.expiry_date;
+        }
+        props.Renew = domain.auto_renew ? 'Auto' : 'Manual';
+    }
+    props.URL = domain.html_url;
+    output_1.default.object(props);
+    output_1.default.exitNormal();
+});
+exports.default = commandDomainGet;

package/distTs/src/command/domain/list.js

@@ -0,0 +1,27 @@
+"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 commandDomainList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_DOMAIN_LIST);
+commandDomainList.alias('ls');
+commandDomainList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandDomainList.action(async (options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const response = await client.getDomains(workspace);
+    if (!response.domains || response.domains.length === 0) {
+        output_1.default.exitError(texts_1.ERR_COMMAND_DOMAIN_NO_DOMAINS);
+    }
+    const data = [['NAME', 'ID', 'URL']];
+    for (const d of response.domains) {
+        data.push([d.name, d.id, d.html_url]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandDomainList;

package/distTs/src/command/domain.js

@@ -0,0 +1,15 @@
+"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 buy_1 = __importDefault(require("./domain/buy"));
+const list_1 = __importDefault(require("./domain/list"));
+const get_1 = __importDefault(require("./domain/get"));
+const commandDomain = (0, utils_1.newCommand)('domain', texts_1.DESC_COMMAND_DOMAIN);
+commandDomain.addCommand(buy_1.default);
+commandDomain.addCommand(list_1.default);
+commandDomain.addCommand(get_1.default);
+exports.default = commandDomain;

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

@@ -51,7 +51,7 @@ const getRemoteNames = (str) => {
     return names;
 };
 const tryNow = () => {
-    output_1.default.cyan('→ ', false);
+    output_1.default.arrowSign();
     output_1.default.label(texts_1.OPT_COMMAND_PROJECT_LINK_TRY_NOW);
     output_1.default.dim('$ ', false);
     output_1.default.light('bdy tunnel http 3000 ', false);

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

@@ -0,0 +1,157 @@
+"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("../vt/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 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":{"width":1920,"height":1080}}]\'');
+            }
+        }
+        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;
+        }
+    }
+}