bdy 1.23.13 → 1.23.14-dev

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

@@ -0,0 +1,49 @@
+"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 scope_1 = require("./scope");
+const commandTargetList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_TARGET_LIST);
+commandTargetList.alias('ls');
+commandTargetList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetList.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetList.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetList.option('--scope <scope>', texts_1.OPT_COMMAND_TARGET_SCOPE);
+commandTargetList.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_LIST}`);
+commandTargetList.action(async (options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project, true);
+    const scope = input_1.default.targetScope(project, options.pipeline, options.environment, options.scope);
+    input_1.default.projectScopeNote(options, project, scope, 'targets');
+    const client = input_1.default.restApiTokenClient();
+    const filters = await (0, scope_1.resolveTargetScope)(client, workspace, project, scope, options);
+    const result = await client.getTargets(workspace, filters);
+    const targets = result.targets || [];
+    if (options.format === 'json') {
+        output_1.default.json(targets);
+    }
+    else {
+        if (targets.length === 0) {
+            output_1.default.exitNormal(texts_1.TXT_TARGET_NOT_FOUND);
+        }
+        const data = [['NAME', 'IDENTIFIER', 'TYPE', 'SCOPE']];
+        for (const target of targets) {
+            data.push([
+                target.name || '-',
+                target.identifier || '-',
+                target.type || '-',
+                (0, scope_1.targetScopeOf)(target),
+            ]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetList;

package/distTs/src/command/target/scope.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTargetScope = exports.targetScopeOf = exports.targetAddressOf = exports.forwardExecLog = exports.resolveTargetId = void 0;
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+// Shared resolve preamble for commands taking a target identifier: line
+// context from flags/env -> /identifiers -> hash id, exiting on a miss.
+//
+// strictLine is for mutating commands (update/delete/exec command): an
+// explicit line flag is a statement "the target of this project/pipeline/
+// environment", yet /identifiers falls back to the workspace target of the
+// same identifier when the requested line exists but does not hold it - the
+// operation would silently land on a workspace-wide resource. Reads keep
+// the fallback (workspace targets stay addressable from a line context).
+const resolveTargetId = async (client, workspace, identifier, options, strictLine = false) => {
+    const project = input_1.default.restApiProject(options.project, true);
+    const line = input_1.default.targetLine(project, options.pipeline, options.environment);
+    const resolved = await client.getTargetByIdentifier(workspace, identifier, line);
+    if (!resolved.target_id) {
+        output_1.default.exitError(texts_1.ERR_TARGET_NOT_FOUND);
+    }
+    if (strictLine) {
+        const requested = options.pipeline
+            ? utils_1.TARGET_SCOPE.PIPELINE
+            : options.environment
+                ? utils_1.TARGET_SCOPE.ENVIRONMENT
+                : options.project
+                    ? utils_1.TARGET_SCOPE.PROJECT
+                    : null;
+        if (requested) {
+            const target = await client.getTarget(workspace, resolved.target_id);
+            const matches = requested === utils_1.TARGET_SCOPE.PIPELINE
+                ? String(target.pipeline?.id) === String(resolved.pipeline_id)
+                : requested === utils_1.TARGET_SCOPE.ENVIRONMENT
+                    ? target.environment?.id === resolved.environment_id
+                    : (0, exports.targetScopeOf)(target) === utils_1.TARGET_SCOPE.PROJECT &&
+                        target.project?.name === resolved.project_identifier;
+            if (!matches) {
+                output_1.default.exitError(texts_1.ERR_TARGET_NOT_FOUND);
+            }
+        }
+    }
+    return resolved.target_id;
+};
+exports.resolveTargetId = resolveTargetId;
+// Lines the CLI requests per log fetch.
+const EXEC_LOG_PAGE = 1000;
+// The exec log endpoint pages by line offset; its `truncated` field
+// describes server-side output truncation, not pagination. `lines` may
+// additionally include a trailing line that is still being written -
+// `next_offset` only advances past committed lines - so exactly
+// next_offset - offset lines are emitted to avoid re-printing the partial
+// line on the next pass. A page shorter than requested means the committed
+// log is drained, so the common case costs a single request.
+const forwardExecLog = async (client, workspace, execId, startOffset, emitPage = (lines) => output_1.default.data(lines.join('\n')), maxLines) => {
+    let offset = startOffset;
+    let emitted = 0;
+    let truncated = false;
+    for (;;) {
+        const pageLimit = maxLines === undefined
+            ? EXEC_LOG_PAGE
+            : Math.min(EXEC_LOG_PAGE, maxLines - emitted);
+        if (pageLimit <= 0)
+            break;
+        const log = await client.getTargetExecLog(workspace, execId, offset, pageLimit);
+        truncated = truncated || !!log.truncated;
+        const next = log.next_offset ?? offset;
+        if (next <= offset)
+            break;
+        const lines = (log.lines || []).slice(0, next - offset);
+        if (lines.length)
+            emitPage(lines);
+        emitted += lines.length;
+        offset = next;
+        if (lines.length < pageLimit)
+            break;
+    }
+    return { offset, truncated };
+};
+exports.forwardExecLog = forwardExecLog;
+// Connection info condensed to one host:port/database cell (auth is left
+// out on purpose - the text view is a summary, credentials stay in json).
+const targetAddressOf = (target) => {
+    if (!target.host)
+        return '-';
+    let address = target.host;
+    if (target.port)
+        address += `:${target.port}`;
+    if (target.database)
+        address += `/${target.database}`;
+    return address;
+};
+exports.targetAddressOf = targetAddressOf;
+const targetScopeOf = (target) => {
+    if (target.pipeline)
+        return utils_1.TARGET_SCOPE.PIPELINE;
+    if (target.environment)
+        return utils_1.TARGET_SCOPE.ENVIRONMENT;
+    if (target.project)
+        return utils_1.TARGET_SCOPE.PROJECT;
+    return utils_1.TARGET_SCOPE.WORKSPACE;
+};
+exports.targetScopeOf = targetScopeOf;
+// Input.targetScope guarantees project is set for the PIPELINE scope.
+// Environments exist on both workspace and project level, so for the
+// ENVIRONMENT scope project is optional and narrows the lookup when given.
+const resolveTargetScope = async (client, workspace, project, scope, options) => {
+    const params = {};
+    if (scope === utils_1.TARGET_SCOPE.PIPELINE) {
+        const { pipeline_id } = await client.getPipelineByIdentifier(workspace, project, options.pipeline);
+        if (!pipeline_id)
+            output_1.default.exitError(texts_1.ERR_PIPELINE_NOT_FOUND);
+        params.pipelineId = pipeline_id;
+    }
+    else if (scope === utils_1.TARGET_SCOPE.ENVIRONMENT) {
+        const query = {
+            environment: options.environment,
+        };
+        if (project)
+            query.project = project;
+        const resolved = await client.getResourceByIdentifier(workspace, query);
+        // a nonexistent project is rejected by getResourceByIdentifier itself
+        if (!resolved.environment_id) {
+            output_1.default.exitError(texts_1.ERR_TARGET_ENVIRONMENT_NOT_FOUND);
+        }
+        params.environmentId = resolved.environment_id;
+    }
+    else if (scope === utils_1.TARGET_SCOPE.PROJECT) {
+        params.project = project;
+    }
+    return params;
+};
+exports.resolveTargetScope = resolveTargetScope;

package/distTs/src/command/target/update.js

@@ -0,0 +1,32 @@
+"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 scope_1 = require("./scope");
+const commandTargetUpdate = (0, utils_1.newCommand)('update', texts_1.DESC_COMMAND_TARGET_UPDATE);
+commandTargetUpdate.alias('edit');
+commandTargetUpdate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetUpdate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetUpdate.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetUpdate.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetUpdate.option('--yaml <content|@path>', texts_1.OPTION_TARGET_YAML);
+commandTargetUpdate.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetUpdate.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_UPDATE}`);
+commandTargetUpdate.action(async (identifier, options) => {
+    const yaml = input_1.default.restApiYaml(options.yaml);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options, 
+    /* strictLine */ true);
+    const body = {
+        yaml: Buffer.from(yaml, 'utf8').toString('base64'),
+    };
+    const result = await client.updateTargetByYaml(workspace, target_id, body);
+    output_1.default.exitSuccess((0, texts_1.TXT_TARGET_UPDATED)(result.identifier, result.html_url));
+});
+exports.default = commandTargetUpdate;

package/distTs/src/command/target.js

@@ -0,0 +1,22 @@
+"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 list_1 = __importDefault(require("./target/list"));
+const get_1 = __importDefault(require("./target/get"));
+const create_1 = __importDefault(require("./target/create"));
+const update_1 = __importDefault(require("./target/update"));
+const delete_1 = __importDefault(require("./target/delete"));
+const exec_1 = __importDefault(require("./target/exec"));
+const commandTarget = (0, utils_1.newCommand)('target', texts_1.DESC_COMMAND_TARGET);
+commandTarget.alias('tg');
+commandTarget.addCommand(list_1.default);
+commandTarget.addCommand(get_1.default);
+commandTarget.addCommand(create_1.default);
+commandTarget.addCommand(update_1.default);
+commandTarget.addCommand(delete_1.default);
+commandTarget.addCommand(exec_1.default);
+exports.default = commandTarget;

package/distTs/src/index.js

@@ -9,7 +9,21 @@ const stream_1 = __importDefault(require("stream"));
 output_1.default.muteNodeWarnings();
 stream_1.default.setDefaultHighWaterMark(false, 65536);
 process.title = 'bdy';
+// Node writes to a pipe asynchronously and process.exit() does not wait for
+// the buffer to drain, so large output piped to another process was cut at a
+// pipe-buffer boundary (files and POSIX TTYs are synchronous already).
+// Blocking mode makes every write land before exit, on all Output paths.
+for (const s of [process.stdout, process.stderr]) {
+    s._handle?.setBlocking?.(true);
+}
+// The cost of blocking mode: a reader that closes early (`bdy ... | head`)
+// turns further writes into EPIPE errors, which surface here as uncaught
+// exceptions. That is the reader saying "got enough", not a failure - end
+// quietly like any well-behaved pipe writer.
+const isEpipe = (err) => err?.code === 'EPIPE' || err?.cause?.code === 'EPIPE';
 process.on('uncaughtException', (err) => {
+    if (isEpipe(err))
+        process.exit(0);
     logger_1.default.fatal(err);
     output_1.default.exitError(err);
 });

package/distTs/src/input.js

@@ -368,8 +368,19 @@ class Input {
         const ApiClient = require('./api/client').default;
         const { token: t, refreshToken, clientId, clientToken, clientSecret, } = this.restApiToken(allowNoToken, token);
         const baseUrl = this.restApiBaseUrl(api, region, t);
+        ApiClient.onRateLimitLow = (remaining, reset) => output_1.default.noteWarning((0, texts_1.WARN_REST_API_RATE_LIMIT_LOW)(remaining, reset));
         return new ApiClient(baseUrl, t, refreshToken, clientId, clientSecret, clientToken);
     }
+    // Stderr note for list commands whose PROJECT scope was inferred (linked
+    // project / BUDDY_PROJECT) rather than requested via -p or --scope, so the
+    // narrowing is never silent.
+    static projectScopeNote(options, project, scope, resource) {
+        if (options.format === 'json' || options.scope || options.project)
+            return;
+        if (scope !== 'PROJECT' || !project)
+            return;
+        output_1.default.note((0, texts_1.TXT_LIST_PROJECT_SCOPE_NOTE)(resource, project));
+    }
     static routeType(type) {
         if (!type)
             return distro_1.ROUTE_TYPE.DIRECT_PROXY;
@@ -1087,6 +1098,54 @@ class Input {
             return distro_1.SCOPE.PROJECT;
         return distro_1.SCOPE.WORKSPACE;
     }
+    static targetScope(project, pipeline, environment, scope) {
+        Input.targetLine(project, pipeline, environment);
+        if (scope) {
+            scope = scope.toUpperCase();
+            if (scope === utils_1.TARGET_SCOPE.WORKSPACE) {
+                return scope;
+            }
+            if (scope === utils_1.TARGET_SCOPE.PROJECT) {
+                if (!project)
+                    output_1.default.exitError(texts_1.ERR_COMMAND_SCOPE_NO_PROJECT);
+                return scope;
+            }
+            if (scope === utils_1.TARGET_SCOPE.PIPELINE) {
+                if (!pipeline)
+                    output_1.default.exitError(texts_1.ERR_TARGET_SCOPE_NO_PIPELINE);
+                return scope;
+            }
+            if (scope === utils_1.TARGET_SCOPE.ENVIRONMENT) {
+                if (!environment)
+                    output_1.default.exitError(texts_1.ERR_TARGET_SCOPE_NO_ENVIRONMENT);
+                return scope;
+            }
+            return output_1.default.exitError(texts_1.ERR_TARGET_SCOPE);
+        }
+        if (pipeline)
+            return utils_1.TARGET_SCOPE.PIPELINE;
+        if (environment)
+            return utils_1.TARGET_SCOPE.ENVIRONMENT;
+        if (project)
+            return utils_1.TARGET_SCOPE.PROJECT;
+        return utils_1.TARGET_SCOPE.WORKSPACE;
+    }
+    // Line context for resolving a target identifier via /identifiers:
+    // params describe one line from workspace down (ws -> project -> pipeline
+    // or environment), searched from the deepest scope up.
+    static targetLine(project, pipeline, environment) {
+        if (pipeline && !project) {
+            output_1.default.exitError(texts_1.ERR_TARGET_PIPELINE_REQUIRES_PROJECT);
+        }
+        if (pipeline && environment) {
+            output_1.default.exitError(texts_1.ERR_TARGET_PIPELINE_ENV_CONFLICT);
+        }
+        return {
+            project: project || undefined,
+            pipeline,
+            environment,
+        };
+    }
     static restApiProject(project, allowNull) {
         const ProjectCfg = require('./project/cfg').default;
         let p = process.env.BUDDY_PROJECT;
@@ -1107,6 +1166,12 @@ class Input {
             output_1.default.exitError(texts_1.ERR_SANDBOX_BOOT_SCRIPT_NOT_EXISTS);
         return node_fs_1.default.readFileSync(p, 'utf8');
     }
+    static tags(tags) {
+        return tags
+            .split(',')
+            .map((t) => t.trim())
+            .filter(Boolean);
+    }
     static restApiYaml(yaml) {
         if (!yaml)
             output_1.default.exitError(texts_1.ERR_REST_API_YAML);

package/distTs/src/output/pipeline.js

@@ -1191,7 +1191,9 @@ class OutputPipeline {
                         this.jsonLog(logs[actionLogsStart]);
                     }
                     else {
-                        output_1.default.normal(output_1.default.getTermKitDimColor(`  ${logs[actionLogsStart]}`));
+                        // log lines are payload inside markup - escape so % and ^
+                        // sequences in build output render verbatim
+                        output_1.default.normal(output_1.default.getTermKitDimColor(`  ${output_1.default.escapeTermKit(logs[actionLogsStart])}`));
                     }
                 }
                 if (action &&
@@ -1221,9 +1223,9 @@ class OutputPipeline {
                             let line = '';
                             if (i > 0)
                                 line += '                ';
-                            line += output_1.default.getTermKitMutedColor(v.key);
+                            line += output_1.default.getTermKitMutedColor(output_1.default.escapeTermKit(v.key));
                             line += output_1.default.getTermKitDimColor(` = "`);
-                            line += output_1.default.getTermKitBlueColor(v.value);
+                            line += output_1.default.getTermKitBlueColor(output_1.default.escapeTermKit(v.value));
                             line += output_1.default.getTermKitDimColor('"');
                             output_1.default.normal(line);
                         });

package/distTs/src/output.js

@@ -134,6 +134,32 @@ class Output {
             msg += '\n';
         getTerminal()(msg);
     }
+    // Payload output (command results, logs, JSON): bypasses terminal-kit,
+    // whose printf-style formatting and ^-markup corrupt data containing
+    // % or ^ sequences. newLine=false emits a mid-stream chunk, keeping
+    // chunk boundaries out of the payload.
+    static data(txt, newLine = true) {
+        process.stdout.write(newLine ? `${txt}\n` : txt);
+    }
+    // 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
+    // works. Only for strings printed via terminal() - ScreenBuffer.put does
+    // not printf-format, so there %% would render double.
+    static escapeTermKit(txt) {
+        return txt.replace(/[%^]/g, '$&$&');
+    }
+    static writeStderr(txt) {
+        process.stderr.write(`${txt}\n`);
+    }
+    // Narration accompanying payload output goes to stderr so stdout stays
+    // parseable by scripts.
+    static note(txt) {
+        this.writeStderr(this.getMutedColor(txt));
+    }
+    static noteWarning(txt) {
+        this.writeStderr(this.getYellowColor(txt));
+    }
     static gray(txt, newLine = true) {
         this.normal(this.getMutedColor(txt), newLine);
     }
@@ -624,7 +650,7 @@ class Output {
         _terminal.grabInput(false);
     }
     static json(json) {
-        this.normal(JSON.stringify(json));
+        this.data(JSON.stringify(json));
     }
     static exitError(err) {
         this.clearUndici();
@@ -642,7 +668,9 @@ class Output {
             if (isDebug)
                 msg += `\n${e.stack}`;
         }
-        getTerminal().red.error(`${msg}\n`);
+        // Raw stderr: error messages carry user/API data (SQL, URLs) that
+        // terminal-kit's %-formatting would corrupt.
+        this.writeStderr(this.getRedColor(String(msg)));
         process.exit(1);
     }
 }