bdy 1.25.6-dev → 1.25.8-dev

package/distTs/src/output/pipeline.js

@@ -65,15 +65,34 @@ class OutputPipeline {
         }
         return await this._runLogsNonInteractive(client, workspace, project, identifier, pipelineId, runId, runActionId, noWait, isJson, semanticExitCode);
     }
-    static async runStatus(client, workspace, project, identifier, pipelineId, runId, noWait, noFollow, isJson, semanticExitCode = false) {
+    static findRuns(result) {
+        if (result.executions.length) {
+            const rows = result.executions.map((run) => [
+                String(run.id),
+                this.runStatusText((run.status || '-')),
+                run.start_date || '-',
+                [run.branch?.name, run.tag?.name, run.pull_request?.name]
+                    .filter(Boolean)
+                    .join(', ') || '-',
+                run.to_revision?.revision?.slice(0, 7) || '-',
+                run.html_url || '-',
+            ]);
+            output_1.default.table([[...texts_1.TXT_PIPELINE_RUN_FIND_COLUMNS], ...rows]);
+        }
+        output_1.default.normal((0, texts_1.TXT_PIPELINE_RUN_FIND_SUMMARY)(result.executions.length, result.scanned));
+        if (result.has_more)
+            output_1.default.normal(texts_1.TXT_PIPELINE_RUN_FIND_MORE);
+    }
+    static async runStatus(client, workspace, project, identifier, pipelineId, runId, noWait, noFollow, isJson, semanticExitCode = false, failedLogs = false) {
         if (output_1.default.isTTY() &&
             !noWait &&
             !noFollow &&
             !isJson &&
-            !semanticExitCode) {
+            !semanticExitCode &&
+            !failedLogs) {
             return await this._runStatusInteractive(client, workspace, project, pipelineId, runId);
         }
-        return await this._runStatusNonInteractive(client, workspace, project, identifier, pipelineId, runId, noWait, noFollow, isJson, semanticExitCode);
+        return await this._runStatusNonInteractive(client, workspace, project, identifier, pipelineId, runId, noWait, noFollow, isJson, semanticExitCode, failedLogs);
     }
     static _canCancel(status) {
         return ![
@@ -1327,7 +1346,12 @@ class OutputPipeline {
             }
         }, false, semanticExitCode);
     }
-    static async _runStatusNonInteractive(client, workspace, project, identifier, pipelineId, runId, noWait, noFollow, isJson, semanticExitCode = false) {
+    static async _runStatusNonInteractive(client, workspace, project, identifier, pipelineId, runId, noWait, noFollow, isJson, semanticExitCode = false, failedLogs = false) {
+        const finishRun = async (run) => {
+            if (failedLogs)
+                await this.failedActionLogs(client, workspace, project, pipelineId, run, isJson);
+            this._exitByStatus(isJson, run.status, semanticExitCode);
+        };
         let run = null;
         let totalFetchesCount = 0;
         const tabs = 40;
@@ -1395,7 +1419,7 @@ class OutputPipeline {
             });
             run = r;
         };
-        run = await this._runStatusLoop(client, workspace, project, pipelineId, runId, (run) => {
+        run = await this._runStatusLoop(client, workspace, project, pipelineId, runId, async (run) => {
             totalFetchesCount += 1;
             if (!noFollow || noWait) {
                 if (isJson)
@@ -1418,9 +1442,8 @@ class OutputPipeline {
                     throw error;
                 }
             }
-            if (noWait) {
-                this._exitByStatus(isJson, run.status, semanticExitCode);
-            }
+            if (noWait)
+                await finishRun(run);
         }, false, semanticExitCode);
         if (isJson) {
             this.jsonRun(identifier, run);
@@ -1465,7 +1488,55 @@ class OutputPipeline {
             output_1.default.normal(this._dimLine());
             output_1.default.normal(this._runActionsLogsHelp(identifier, runId));
         }
-        this._exitByStatus(isJson, run.status, semanticExitCode);
+        await finishRun(run);
+    }
+    static async failedActionLogs(client, workspace, project, pipelineId, run, isJson) {
+        for (const action of run.actions) {
+            if (action.status !== pipeline_1.PIPELINE_RUN_STATUS.FAILED)
+                continue;
+            const identity = {
+                action_run_id: action.runId,
+                action_name: action.name,
+            };
+            try {
+                let page = await client.getPipelineRunActionLogs(workspace, project, pipelineId, run.runId, action.runId, 0, texts_1.FAILED_LOGS_LIMIT);
+                if (typeof page.total_element_count !== 'number' ||
+                    !Number.isInteger(page.total_element_count) ||
+                    page.total_element_count < 0) {
+                    throw new cliError_1.default('command_failed', texts_1.ERR_PIPELINE_FAILED_LOGS_COUNT);
+                }
+                // The count lets us jump to the tail without downloading the full log.
+                if (page.total_element_count > texts_1.FAILED_LOGS_LIMIT) {
+                    page = await client.getPipelineRunActionLogs(workspace, project, pipelineId, run.runId, action.runId, page.total_element_count - texts_1.FAILED_LOGS_LIMIT, texts_1.FAILED_LOGS_LIMIT);
+                }
+                if (!isJson)
+                    output_1.default.data((0, texts_1.TXT_PIPELINE_FAILED_LOGS_HEADER)(action.name, action.runId));
+                const logs = page.logs.slice(-texts_1.FAILED_LOGS_LIMIT);
+                if (!logs.length) {
+                    if (isJson)
+                        output_1.default.json({
+                            type: 'info',
+                            ...identity,
+                            message: texts_1.TXT_PIPELINE_FAILED_LOGS_EMPTY,
+                        });
+                    else
+                        output_1.default.data(texts_1.TXT_PIPELINE_FAILED_LOGS_EMPTY);
+                }
+                for (const log of logs) {
+                    if (isJson)
+                        output_1.default.json({ type: 'log', ...identity, log });
+                    else
+                        output_1.default.data(log);
+                }
+            }
+            catch (error) {
+                const details = cliError_1.default.details(error);
+                if (isJson)
+                    output_1.default.json({ type: 'warning', ...identity, error: details });
+                else
+                    output_1.default.noteWarning((0, texts_1.TXT_PIPELINE_FAILED_LOGS_ERROR)(action.name, action.runId, details.message));
+            }
+        }
     }
     static async _actionLogsLoop(client, workspace, project, pipelineId, runId, actionExecutionId, onChange) {
         let logs = [];
@@ -1664,11 +1735,11 @@ class OutputPipeline {
                     context = {};
                 context['Environment'] = run.environment.identifier;
             }
-            if (run.package && run.package_version) {
+            if (run.artifact && run.artifact_version) {
                 if (!context)
                     context = {};
-                context['Package'] =
-                    `${run.package.identifier}:${run.package_version.version}`;
+                context['Artifact'] =
+                    `${run.artifact.identifier}:${run.artifact_version.version}`;
             }
             if (run.loop_details) {
                 if (!context)
@@ -1768,7 +1839,7 @@ class OutputPipeline {
                 context,
                 actions,
             };
-            onChange(r, forceFetchRun);
+            await onChange(r, forceFetchRun);
             return r;
         };
         lastRun = await forceFetchRun();

package/distTs/src/output.js

@@ -187,6 +187,15 @@ class Output {
     static data(txt, newLine = true) {
         process.stdout.write(newLine ? `${txt}\n` : txt);
     }
+    static examples(command, examples, format) {
+        if (format === 'json')
+            return this.json({ command, examples });
+        if (format === 'jsonl')
+            return this.json({ type: 'examples', command, examples });
+        if (!examples.length)
+            return this.data(`No examples for ${command}.`);
+        this.data(`EXAMPLES:\n${examples.map((example) => `  ### ${example.description}\n  ${example.command}`).join('\n')}`);
+    }
     // For payload embedded in terminal-kit markup (e.g. a dimmed log line):
     // neutralizes the ^-markup and %-formatting the payload would otherwise
     // trigger, so it renders verbatim while the surrounding markup still
@@ -375,7 +384,15 @@ class Output {
             }
         });
     }
-    static async confirm(message = 'Are you sure?') {
+    static async confirmDestructive(force, message, quiet = false) {
+        if (force)
+            return true;
+        if (!this.isStdInTTY()) {
+            throw new cliError_1.default('usage_error', texts_1.ERR_CONFIRM_REQUIRED, texts_1.TXT_CONFIRM_FORCE_HINT);
+        }
+        return await this.confirm(message, quiet);
+    }
+    static async confirm(message = 'Are you sure?', quiet = false) {
         if (this.isStdInTTY()) {
             const prompts = require('@inquirer/prompts');
             try {
@@ -383,15 +400,17 @@ class Output {
                     message,
                     theme: this.getInquirerTheme(),
                     default: false,
-                });
+                }, quiet ? { output: process.stderr } : undefined);
             }
             catch {
                 this.exitError(texts_1.ERR_CANCELLED);
             }
         }
-        this.cyan('? ', false);
-        this.label(message, false);
-        this.cyan(` No`);
+        if (!quiet) {
+            this.cyan('? ', false);
+            this.label(message, false);
+            this.cyan(` No`);
+        }
         return false;
     }
     static async inputString(message, def, required, signal) {

package/distTs/src/project/context.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBuddyRemote = parseBuddyRemote;
+exports.resolveContextScope = resolveContextScope;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const cliError_1 = __importDefault(require("../cliError"));
+const utils_1 = require("../utils");
+const texts_1 = require("../texts");
+function parseBuddyRemote(remote) {
+    try {
+        // Accept both standard URLs and Git's scp-like SSH syntax.
+        const value = remote.includes('://')
+            ? remote
+            : remote.replace(/^(?:[^@/:]+@)?([^/:]+):(.+)$/, 'ssh://$1/$2');
+        const url = new URL(value);
+        if (!['https:', 'ssh:'].includes(url.protocol) ||
+            !Object.values(utils_1.REST_API_ENDPOINT).some((endpoint) => (0, utils_1.getAppHostByApiBaseUrl)(new URL(`https://${endpoint}`)) ===
+                url.hostname) ||
+            url.search ||
+            url.hash)
+            throw new Error();
+        const parts = url.pathname
+            .replace(/\/$/, '')
+            .replace(/\.git$/, '')
+            .split('/')
+            .slice(1);
+        if (parts.length !== 2 ||
+            parts.some((part) => !/^[a-zA-Z0-9_-]+$/.test(part)))
+            throw new Error();
+        return { workspace: parts[0], project: parts[1] };
+    }
+    catch {
+        // Do not include the raw URL: remotes can contain credentials.
+        throw new cliError_1.default('git_remote_unsupported', texts_1.ERR_CONTEXT_GIT_URL, texts_1.TXT_CONTEXT_GIT_HINT);
+    }
+}
+function resolveContextScope(context, cwd) {
+    if (context.source === 'explicit')
+        return {
+            workspace: context.workspace || null,
+            project: context.project || null,
+            remote: null,
+        };
+    if (context.source === 'link') {
+        let data;
+        try {
+            data = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(cwd, '.bdy/project.json'), 'utf8'));
+        }
+        catch (err) {
+            const missing = err.code === 'ENOENT';
+            throw new cliError_1.default(missing ? 'project_link_not_found' : 'project_link_invalid', missing ? texts_1.ERR_CONTEXT_LINK_MISSING : texts_1.ERR_CONTEXT_LINK_INVALID, texts_1.TXT_CONTEXT_LINK_HINT);
+        }
+        if (typeof data?.workspace !== 'string' ||
+            !data.workspace.trim() ||
+            typeof data?.project !== 'string' ||
+            !data.project.trim())
+            throw new cliError_1.default('project_link_invalid', texts_1.ERR_CONTEXT_LINK_INVALID, texts_1.TXT_CONTEXT_LINK_HINT);
+        return {
+            workspace: data.workspace,
+            project: data.project,
+            remote: null,
+        };
+    }
+    const remote = context.remote || 'origin';
+    let url;
+    try {
+        url = (0, node_child_process_1.execFileSync)('git', ['remote', 'get-url', '--', remote], {
+            cwd,
+            encoding: 'utf8',
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            // Git diagnostics are classified below; keep their language deterministic.
+            env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+        }).trim();
+    }
+    catch (err) {
+        const failure = err;
+        if (failure.code === 'ENOENT')
+            throw new cliError_1.default('git_not_found', texts_1.ERR_CONTEXT_GIT_MISSING, texts_1.TXT_CONTEXT_GIT_HINT);
+        if (failure.code === 'ETIMEDOUT')
+            throw new cliError_1.default('timeout', texts_1.ERR_CONTEXT_GIT_TIMEOUT, texts_1.TXT_CONTEXT_GIT_HINT);
+        const stderr = String(failure.stderr || '');
+        if (failure.status === 128 && /fatal: not a git repository/i.test(stderr))
+            throw new cliError_1.default('git_repository_not_found', texts_1.ERR_CONTEXT_GIT_REPO, texts_1.TXT_CONTEXT_GIT_HINT);
+        if (failure.status === 2 && /error: No such remote /i.test(stderr))
+            throw new cliError_1.default('git_remote_not_found', (0, texts_1.ERR_CONTEXT_GIT_REMOTE)(remote), texts_1.TXT_CONTEXT_GIT_HINT);
+        // Neither permission errors nor an interrupted Git process imply a missing repo.
+        // Never forward raw diagnostics, which may contain remote credentials.
+        throw new cliError_1.default('command_failed', texts_1.ERR_CONTEXT_GIT_FAILED, texts_1.TXT_CONTEXT_GIT_HINT);
+    }
+    return { ...parseBuddyRemote(url), remote };
+}