bdy 1.19.1-dev-pipeline → 1.19.2-dev

package/distTs/package.json

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

package/distTs/src/api/client.js

@@ -216,37 +216,6 @@ 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',
@@ -287,34 +256,6 @@ 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',
@@ -780,14 +721,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/pipeline/run.js

@@ -5,27 +5,130 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../../utils");
 const texts_1 = require("../../texts");
-const status_1 = __importDefault(require("./run/status"));
-const start_1 = __importDefault(require("./run/start"));
-const logs_1 = __importDefault(require("./run/logs"));
-const cancel_1 = __importDefault(require("./run/cancel"));
-const retry_1 = __importDefault(require("./run/retry"));
-const list_1 = __importDefault(require("./run/list"));
-const approve_1 = __importDefault(require("./run/approve"));
+const output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const format_1 = __importDefault(require("../../format"));
 const commandPipelineRun = (0, utils_1.newCommand)('run', texts_1.DESC_COMMAND_PIPELINE_RUN);
-commandPipelineRun.addCommand(start_1.default);
-commandPipelineRun.addCommand(status_1.default);
-commandPipelineRun.addCommand(logs_1.default);
-commandPipelineRun.addCommand(cancel_1.default);
-commandPipelineRun.addCommand(retry_1.default);
-commandPipelineRun.addCommand(approve_1.default);
-commandPipelineRun.addCommand(list_1.default);
-commandPipelineRun.addHelpText('after', `
-EXAMPLES:${texts_1.EXAMPLE_PIPELINE_RUN_START}
-${texts_1.EXAMPLE_PIPELINE_RUN_STATUS}
-${texts_1.EXAMPLE_PIPELINE_RUN_LOGS}
-${texts_1.EXAMPLE_PIPELINE_RUN_CANCEL}
-${texts_1.EXAMPLE_PIPELINE_RUN_RETRY}
-${texts_1.EXAMPLE_PIPELINE_RUN_APPLY}
-${texts_1.EXAMPLE_PIPELINE_RUN_LIST}`);
+commandPipelineRun.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPipelineRun.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPipelineRun.option('-b, --branch <branch>', texts_1.OPTION_PIPELINE_RUN_BRANCH);
+commandPipelineRun.option('-t, --tag <tag>', texts_1.OPTION_PIPELINE_RUN_TAG);
+commandPipelineRun.option('-pr, --pull-request <pull request>', texts_1.OPTION_PIPELINE_RUN_PULL_REQUEST);
+commandPipelineRun.option('-r, --revision <revision>', texts_1.OPTION_PIPELINE_RUN_REVISION);
+commandPipelineRun.option('--comment <comment>', texts_1.OPTION_PIPELINE_RUN_COMMENT);
+commandPipelineRun.option('-f, --refresh', texts_1.OPTION_PIPELINE_RUN_REFRESH);
+commandPipelineRun.option('-c, --clear-cache', texts_1.OPTION_PIPELINE_RUN_CLEAR_CACHE);
+commandPipelineRun.option('--priority <priority>', texts_1.OPTION_PIPELINE_RUN_PRIORITY);
+commandPipelineRun.option('-v, --variable <variables...>', texts_1.OPTION_PIPELINE_RUN_VAR);
+commandPipelineRun.option('-vm, --variable-masked <variables...>', texts_1.OPTION_PIPELINE_RUN_VAR);
+commandPipelineRun.option('--schedule <date>', texts_1.OPTION_PIPELINE_RUN_DELAY);
+commandPipelineRun.option('--action <actions...>', texts_1.OPTION_PIPELINE_RUN_ACTION);
+commandPipelineRun.option('--wait [minutes]', texts_1.OPTION_PIPELINE_RUN_WAIT);
+commandPipelineRun.argument('<identifier>', texts_1.OPTION_PIPELINE_RUN_ARGUMENT);
+commandPipelineRun.usage('<identifier> [options]');
+commandPipelineRun.addHelpText('after', texts_1.EXAMPLE_PIPELINE_RUN);
+commandPipelineRun.action(async (identifier, options) => {
+    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 body = {};
+    if (options.branch) {
+        body.branch = {
+            name: options.branch,
+        };
+    }
+    if (options.tag) {
+        body.tag = {
+            name: options.tag,
+        };
+    }
+    if (options.pullRequest) {
+        body.pull_request = {
+            name: `pull/${options.pullRequest}`,
+        };
+    }
+    if (options.revision) {
+        body.to_revision = {
+            revision: options.revision,
+        };
+    }
+    if (options.comment) {
+        body.comment = options.comment;
+    }
+    if (options.refresh) {
+        body.refresh = true;
+    }
+    if (options.clearCache) {
+        body.clear_cache = true;
+    }
+    const priority = input_1.default.pipelineRunPriority(options.priority);
+    if (priority) {
+        body.priority = priority;
+    }
+    body.variables = [];
+    if (options.variable) {
+        body.variables = body.variables.concat(input_1.default.pipelineRunVariable(options.variable, false));
+    }
+    if (options.variableMasked) {
+        body.variables = body.variables.concat(input_1.default.pipelineRunVariable(options.variableMasked, true));
+    }
+    const delay = input_1.default.pipelineRunDelay(options.schedule);
+    if (delay) {
+        body.delay_until = delay;
+    }
+    const actions = input_1.default.pipelineRunAction(options.action);
+    if (actions) {
+        body.actions_to_run = actions;
+    }
+    const result = await client.pipelineRun(workspace, project, data.pipeline_id, body);
+    if (options.wait) {
+        const minutes = input_1.default.pipelineRunWaitTime(options.wait);
+        wait(minutes, workspace, project, data.pipeline_id, result.id, result.html_url, client);
+    }
+    else {
+        output_1.default.exitSuccess((0, texts_1.TXT_PIPELINE_RUN_SUCCESS)(result.html_url));
+    }
+});
+const wait = (minutes, workspace, project, pipelineId, runId, htmlUrl, client) => {
+    const start = Date.now();
+    output_1.default.normal((0, texts_1.TXT_PIPELINE_RUN_WAIT)(minutes));
+    let fetchCounter = 1;
+    const ts1 = setTimeout(() => {
+        output_1.default.exitError(texts_1.ERR_RUN_PIPELINE_WAIT_TIMEOUT);
+    }, minutes * 60 * 1000);
+    const ts2 = setInterval(async () => {
+        output_1.default.clearPreviousLine();
+        output_1.default.normal((0, texts_1.TXT_PIPELINE_RUN_STILL_WAITING)(formatWaitTime(start)));
+        if (fetchCounter >= 3) {
+            const run = await client.getPipelineRun(workspace, project, pipelineId, runId);
+            if (!['INPROGRESS', 'ENQUEUED', 'TERMINATING'].includes(run.status)) {
+                clearTimeout(ts1);
+                clearInterval(ts2);
+                output_1.default.clearPreviousLine();
+                if (run.status === 'SUCCESSFUL') {
+                    output_1.default.exitSuccess((0, texts_1.TXT_PIPELINE_RUN_FINISH_SUCCESSFULLY)(htmlUrl));
+                }
+                else {
+                    output_1.default.exitError((0, texts_1.TXT_PIPELINE_RUN_FINISH_FAILED)(run.status, htmlUrl));
+                }
+            }
+            fetchCounter = 0;
+        }
+        fetchCounter += 1;
+    }, 1000);
+};
+const formatWaitTime = (start) => {
+    const elapsed = Math.floor((Date.now() - start) / 1000);
+    return format_1.default.pipelineRunWaitTime(elapsed);
+};
 exports.default = commandPipelineRun;

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_1 = __importDefault(require("../../tunnel/cfg"));
+const output_1 = __importDefault(require("../../output"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const commandProjectGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_PROJECT_GET);
+commandProjectGet.action(async () => {
+    const project = cfg_1.default.getProject();
+    if (!project) {
+        output_1.default.exitError(texts_1.TXT_PROJECT_NONE);
+    }
+    output_1.default.exitNormal(project);
+});
+exports.default = commandProjectGet;

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

@@ -23,7 +23,7 @@ commandProjectLink.action(async (dir, options) => {
     ProjectCfg.init(path, workspace, project);
     output_1.default.okSign();
     output_1.default.normal(texts_1.TXT_COMMAND_PROJECT_LINK_TO, false);
-    output_1.default.cyan(` ${url}`);
+    output_1.default.light(` ${url}`);
     await initRepo(workspace, project, path, git, options);
     tryNow();
     output_1.default.exitNormal();
@@ -54,13 +54,13 @@ const tryNow = () => {
     output_1.default.arrowSign();
     output_1.default.label(texts_1.OPT_COMMAND_PROJECT_LINK_TRY_NOW);
     output_1.default.dim('$ ', false);
-    output_1.default.cyan('bdy tunnel http 3000 ', false);
+    output_1.default.light('bdy tunnel http 3000 ', false);
     output_1.default.muted('                  Expose localhost:3000 to the internet');
     output_1.default.dim('$ ', false);
-    output_1.default.cyan('bdy artifact publish . ', false);
+    output_1.default.light('bdy artifact publish . ', false);
     output_1.default.muted('                 Publish an artifact from the current project');
     output_1.default.dim('$ ', false);
-    output_1.default.cyan('bdy sandbox create --run "npm start" ', false);
+    output_1.default.light('bdy sandbox create --run "npm start" ', false);
     output_1.default.muted('  Spin up a cloud sandbox and run your app');
 };
 const initRepo = async (workspace, project, path, git, options) => {
@@ -89,16 +89,16 @@ const initRepo = async (workspace, project, path, git, options) => {
         });
         output_1.default.okSign();
         output_1.default.normal('Remote ', false);
-        output_1.default.cyan('origin ', false);
+        output_1.default.light('origin ', false);
         output_1.default.normal('set to ', false);
-        output_1.default.cyan(remote);
+        output_1.default.light(remote);
     }
     else if (remotes.origin !== remote) {
         output_1.default.yellow(texts_1.OPT_COMMAND_PROJECT_LINK_HAS_REMOTE);
         output_1.default.normal('Current origin: ', false);
-        output_1.default.cyan(remotes.origin);
+        output_1.default.light(remotes.origin);
         output_1.default.normal('Buddy project: ', false);
-        output_1.default.cyan(remote);
+        output_1.default.light(remote);
         const opt = await output_1.default.inputMenuAdv(texts_1.OPT_COMMAND_PROJECT_LINK_SET_GIT_REMOTE, [
             {
                 name: 'Add buddy remote',
@@ -127,9 +127,9 @@ const initRepo = async (workspace, project, path, git, options) => {
             });
             output_1.default.okSign();
             output_1.default.normal('Remote ', false);
-            output_1.default.cyan('buddy ', false);
+            output_1.default.light('buddy ', false);
             output_1.default.normal('set to ', false);
-            output_1.default.cyan(remote);
+            output_1.default.light(remote);
         }
         else if (opt === 'origin') {
             await (0, utils_1.execLocally)(`git remote rm origin`, {
@@ -140,7 +140,7 @@ const initRepo = async (workspace, project, path, git, options) => {
             });
             output_1.default.okSign();
             output_1.default.normal('Origin replaced with ', false);
-            output_1.default.cyan(remote);
+            output_1.default.light(remote);
         }
         else {
             return;

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

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_1 = __importDefault(require("../../tunnel/cfg"));
+const output_1 = __importDefault(require("../../output"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const input_1 = __importDefault(require("../../input"));
+const commandProjectSet = (0, utils_1.newCommand)('set', texts_1.DESC_COMMAND_PROJECT_SET);
+commandProjectSet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandProjectSet.argument('[project]', texts_1.ARG_COMMAND_PROJECT_NAME);
+commandProjectSet.action(async (project, options) => {
+    output_1.default.handleSignals();
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    if (project) {
+        await client.getProject(workspace, project);
+    }
+    else {
+        const response = await client.getProjects(workspace);
+        project = await output_1.default.selectProject(response.projects);
+    }
+    cfg_1.default.setProject(project);
+    if (!project)
+        output_1.default.exitSuccess(texts_1.TXT_PROJECT_SET_CLEARED);
+    else
+        output_1.default.exitSuccess((0, texts_1.TXT_PROJECT_SET_SUCCESS)(project));
+});
+exports.default = commandProjectSet;

package/distTs/src/command/sandbox/get/yaml.js

@@ -0,0 +1,30 @@
+"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 commandSandboxGetYaml = (0, utils_1.newCommand)('yaml', texts_1.DESC_COMMAND_SANDBOX_GET_YAML);
+commandSandboxGetYaml.hideVersionUpdate = true;
+commandSandboxGetYaml.alias('yml');
+commandSandboxGetYaml.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxGetYaml.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxGetYaml.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxGetYaml.action(async (identifier, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = input_1.default.restApiTokenClient();
+    let result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    const sandboxId = found.id;
+    result = await client.getSandboxYaml(workspace, sandboxId);
+    output_1.default.exitNormal(Buffer.from(result.yaml, 'base64').toString('utf8'));
+});
+exports.default = commandSandboxGetYaml;

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

@@ -0,0 +1,193 @@
+"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 validation_1 = require("../../visualTest/validation");
+const output_1 = __importDefault(require("../../output"));
+const requests_1 = require("../../visualTest/requests");
+const zod_1 = require("zod");
+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 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);
+commandScrape.addOption(new commander_1.Option('--outputType <type>', texts_1.OPTION_SCRAPE_OUTPUT_TYPE)
+    .choices(['jpeg', 'png', 'md', 'html'])
+    .makeOptionMandatory());
+commandScrape.option('--quality <quality>', texts_1.OPTION_SCRAPE_QUALITY);
+commandScrape.option('--fullPage', texts_1.OPTION_SCRAPE_FULL_PAGE, false);
+commandScrape.option('--cssSelector <selector>', texts_1.OPTION_SCRAPE_CSS_SELECTOR);
+commandScrape.option('--xpathSelector <selector>', texts_1.OPTION_SCRAPE_XPATH_SELECTOR);
+commandScrape.addOption(new commander_1.Option('--browser <browser>', texts_1.OPTION_SCRAPE_BROWSER)
+    .choices(['chrome', 'firefox', 'safari'])
+    .default('chrome'));
+commandScrape.option('--viewport <viewport>', texts_1.OPTION_SCRAPE_VIEWPORT, '1920x1080');
+commandScrape.option('--devicePixelRatio <ratio>', texts_1.OPTION_SCRAPE_DEVICE_PIXEL_RATIO, '1');
+commandScrape.option('--waitForElement <selector>', texts_1.OPTION_SCRAPE_WAIT_FOR_ELEMENT);
+commandScrape.option('--darkMode', texts_1.OPTION_SCRAPE_DARK_MODE, false);
+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) => {
+    if (!(0, validation_1.checkToken)()) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    const { url, follow, outputType, quality, outputDir, fullPage, cssSelector, xpathSelector, browser, viewport, devicePixelRatio, darkMode, delay, waitForElement, } = validateInputAndOptions(inputUrl, options);
+    try {
+        const { buildId } = await (0, requests_1.sendScrap)(url, outputType, follow, quality, fullPage, cssSelector, xpathSelector, browser, viewport, devicePixelRatio, darkMode, delay, waitForElement);
+        output_1.default.normal('Starting scrape session');
+        const status = await watchSessionStatus(buildId);
+        if (!status.ok) {
+            output_1.default.exitError(`Unexpected error while watching session status: ${status.error}`);
+        }
+        output_1.default.normal('Downloading scrape package');
+        const scrapPackageStream = await (0, requests_1.downloadScrapPackage)(buildId);
+        const brotliDecompressor = (0, node_zlib_1.createBrotliDecompress)();
+        const unpack = tar_stream_1.default.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 scrape package finished');
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+function validateInputAndOptions(input, options) {
+    const urlSchema = zod_1.z.string().url();
+    const optionsSchema = zod_1.z.object({
+        follow: zod_1.z.boolean(),
+        outputType: zod_1.z.enum(['jpeg', 'png', 'md', 'html']),
+        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(),
+        browser: zod_1.z.enum(['chrome', 'firefox', 'safari']),
+        viewport: zod_1.z
+            .string()
+            .refine((value) => {
+            const [width, height] = value.split('x');
+            return (width &&
+                height &&
+                !isNaN(Number(width)) &&
+                !isNaN(Number(height)) &&
+                Number(width) > 0 &&
+                Number(height) > 0);
+        }, 'Invalid viewport format, example: 1920x1080')
+            .transform((value) => {
+            const [width, height] = value.split('x');
+            return {
+                width: Number(width),
+                height: Number(height),
+            };
+        }),
+        devicePixelRatio: zod_1.z.coerce.number().min(1).max(4),
+        darkMode: zod_1.z.boolean(),
+        delay: zod_1.z.coerce.number().min(0).max(10000),
+        waitForElement: zod_1.z.string().optional(),
+    });
+    try {
+        const url = urlSchema.parse(input);
+        const { follow, outputType, quality, outputDir, fullPage, cssSelector, xpathSelector, browser, viewport, devicePixelRatio, darkMode, delay, waitForElement, } = optionsSchema.parse(options);
+        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');
+        }
+        return {
+            url,
+            follow,
+            outputType,
+            quality,
+            outputDir,
+            fullPage,
+            cssSelector,
+            xpathSelector,
+            browser,
+            viewport,
+            devicePixelRatio,
+            darkMode,
+            delay,
+            waitForElement,
+        };
+    }
+    catch (error) {
+        if (error instanceof zod_1.ZodError) {
+            output_1.default.exitError(error.errors.map((e) => `${e.path}: ${e.message}`).join(', '));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function watchSessionStatus(buildId) {
+    return new Promise((resolve) => {
+        const eventSource = (0, requests_1.connectToScrapSession)(buildId);
+        eventSource.addEventListener('SESSION_STATUS', (event) => {
+            const data = JSON.parse(event.data);
+            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(`Scraping ${data.text} completed`);
+            }
+            else if (data.status === 'SCRAPE_URL_FAILED') {
+                output_1.default.error(`Scraping ${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 === 'FINISHED') {
+                eventSource.close();
+                output_1.default.normal('Scrape session finished');
+                resolve({ ok: true });
+            }
+        });
+        eventSource.addEventListener('error', (event) => {
+            if (event.code) {
+                eventSource.close();
+                if (event.code === 410) {
+                    output_1.default.normal('Scrape session finished');
+                }
+                resolve({ ok: event.code === 410, error: event.code });
+            }
+        });
+    });
+}
+exports.default = commandScrape;

package/distTs/src/input.js

@@ -334,8 +334,8 @@ class Input {
     }
     static restApiTokenClient(allowNoToken = false, api = '', region = '', token = '') {
         const ApiClient = require('./api/client').default;
-        const baseUrl = this.restApiBaseUrl(api, region);
         const { token: t, refreshToken, clientId, clientToken, clientSecret, } = this.restApiToken(allowNoToken, token);
+        const baseUrl = this.restApiBaseUrl(api, region, t);
         return new ApiClient(baseUrl, t, refreshToken, clientId, clientSecret, clientToken);
     }
     static artifactType(type) {
@@ -350,17 +350,6 @@ class Input {
             return utils_1.ARTIFACT_SCOPE.PROJECT;
         return utils_1.ARTIFACT_SCOPE.WORKSPACE;
     }
-    static pipelineRunId(runId) {
-        const r = parseInt(runId, 10);
-        if (!isNaN(r))
-            return r;
-        output_1.default.exitError(texts_1.ERR_RUN_PIPELINE_WRONG_RUN_ID);
-    }
-    static pipelineRunActionId(runActionId) {
-        if (runActionId)
-            return runActionId;
-        output_1.default.exitError(texts_1.ERR_RUN_PIPELINE_WRONG_RUN_ACTION_ID);
-    }
     static pipelineRunPriority(priority) {
         if (!priority)
             return null;
@@ -442,8 +431,26 @@ class Input {
             output_1.default.exitError(texts_1.ERR_REST_API_REGION);
         }
     }
-    static restApiBaseUrl(api = '', region = '') {
-        let u = api || process.env.BUDDY_API_ENDPOINT;
+    static restApiBaseUrlFromToken(token) {
+        // bdy_sb_us_aHR0cHM6Ly9hcGkuc2Q1LmNvbQ_f92ml8f1p27nzo45806vczm6c78d0
+        const s = (token || '').split('_');
+        if (s.length > 1) {
+            const base = s[s.length - 2];
+            try {
+                return Buffer.from(base, 'base64').toString('utf8');
+            }
+            catch {
+                // do nothing
+            }
+        }
+        return null;
+    }
+    static restApiBaseUrl(api = '', region = '', token = '') {
+        let u = api;
+        if (!u)
+            u = this.restApiBaseUrlFromToken(token);
+        if (!u)
+            u = process.env.BUDDY_API_ENDPOINT || null;
         if (!u)
             u = cfg_1.default.getBaseUrl();
         if (!u) {
@@ -468,6 +475,16 @@ class Input {
             output_1.default.exitError(texts_1.ERR_REST_API_URL);
         }
     }
+    static pipelineRunWaitTime(time) {
+        let t = Number.parseInt(time, 10);
+        if (!t)
+            t = 1440;
+        else if (t < 0)
+            t = 1;
+        else if (t > 1440)
+            t = 1440;
+        return t;
+    }
     static resolvePath(path) {
         const p = (0, node_path_1.resolve)(path);
         const exists = node_fs_1.default.existsSync(p);