bdy 1.23.15-dev-target-commands → 1.23.15-dev

package/distTs/src/command/pre.js

@@ -46,14 +46,15 @@ const commandPre = async (_, command) => {
     if (!output_1.default.isTTY() || command.hideVersionUpdate || ['json', 'jsonl'].includes(command.opts()?.format)) {
         return;
     }
-    const newCli = !!command.latestVersion && command.currentVersion !== command.latestVersion;
-    const newAgent = !!command.agentStatus && !!command.latestVersion &&
-        command.agentStatus.version !== command.latestVersion;
-    if ((0, utils_1.isDocker)() && newCli && command.latestVersion) {
-        output_1.default.newCliDockerVersion(command.latestVersion);
-    }
-    else if (newCli && command.latestVersion) {
-        output_1.default.newCliVersion(command.latestVersion);
+    // No truthiness guards on the versions: an empty or unparsable one is never newer
+    const latest = command.latestVersion || '';
+    const newCli = (0, utils_1.isVersionNewer)(latest, command.currentVersion || '');
+    const newAgent = !!command.agentStatus && (0, utils_1.isVersionNewer)(latest, command.agentStatus.version);
+    if ((0, utils_1.isDocker)() && newCli) {
+        output_1.default.newCliDockerVersion(latest);
+    }
+    else if (newCli) {
+        output_1.default.newCliVersion(latest);
     }
     else if (newAgent) {
         output_1.default.newAgentVersion();

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/git/credential.js

@@ -60,10 +60,12 @@ commandProjectGitCredential.action(async (action) => {
                     projects.projects[0].html_url.includes(input.host);
         }
         if (myHost) {
-            output_1.default.normal(`protocol=${input.protocol || 'https'}`);
-            output_1.default.normal(`host=${input.host}`);
-            output_1.default.normal(`username=${client.token}`);
-            output_1.default.normal(`password=`);
+            // git credential protocol output - a machine-read payload, so it
+            // bypasses terminal-kit formatting
+            output_1.default.data(`protocol=${input.protocol || 'https'}`);
+            output_1.default.data(`host=${input.host}`);
+            output_1.default.data(`username=${client.token}`);
+            output_1.default.data(`password=`);
         }
     }
     catch {

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/exec/command.js

@@ -43,7 +43,7 @@ commandSandboxExecCommand.action(async (identifier, command, options) => {
                     str.forEach((s) => {
                         const json = JSON.parse(s);
                         if (json.data)
-                            output_1.default.normal(json.data);
+                            output_1.default.data(json.data);
                     });
                 }
                 catch {

package/distTs/src/command/sandbox/exec/logs.js

@@ -31,7 +31,7 @@ commandSandboxExecLogs.action(async (identifier, commandId, options) => {
                 str.forEach((s) => {
                     const json = JSON.parse(s);
                     if (json.data)
-                        output_1.default.normal(json.data);
+                        output_1.default.data(json.data);
                 });
             }
             catch {

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/target/delete.js

@@ -20,7 +20,8 @@ commandTargetDelete.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_DE
 commandTargetDelete.action(async (identifier, options) => {
     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);
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options, 
+    /* strictLine */ true);
     const confirmed = options.force || (await output_1.default.confirm((0, texts_1.TXT_TARGET_DELETE_CONFIRM)(identifier)));
     if (!confirmed)
         output_1.default.exitNormal();

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

@@ -41,7 +41,8 @@ commandTargetExecCommand.action(async (identifier, command, options) => {
     }
     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);
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options, 
+    /* strictLine */ true);
     let exec = await client.executeTargetCommand(workspace, target_id, {
         command: cmd,
     });

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

@@ -10,14 +10,42 @@ 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.
-const resolveTargetId = async (client, workspace, identifier, options) => {
+//
+// 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 { target_id } = await client.getTargetByIdentifier(workspace, identifier, line);
-    if (!target_id) {
+    const resolved = await client.getTargetByIdentifier(workspace, identifier, line);
+    if (!resolved.target_id) {
         output_1.default.exitError(texts_1.ERR_TARGET_NOT_FOUND);
     }
-    return target_id;
+    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.
@@ -96,12 +124,7 @@ const resolveTargetScope = async (client, workspace, project, scope, options) =>
         if (project)
             query.project = project;
         const resolved = await client.getResourceByIdentifier(workspace, query);
-        // /identifiers falls back to the workspace environment even when the
-        // requested project does not exist; a provided project must itself
-        // resolve or the scope would silently point elsewhere.
-        if (project && !resolved.project_identifier) {
-            output_1.default.exitError(texts_1.ERR_PROJECT_NOT_FOUND);
-        }
+        // a nonexistent project is rejected by getResourceByIdentifier itself
         if (!resolved.environment_id) {
             output_1.default.exitError(texts_1.ERR_TARGET_ENVIRONMENT_NOT_FOUND);
         }

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

@@ -21,7 +21,8 @@ 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);
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options, 
+    /* strictLine */ true);
     const body = {
         yaml: Buffer.from(yaml, 'utf8').toString('base64'),
     };

package/distTs/src/command/version.js

@@ -78,7 +78,7 @@ commandVersion.action(async () => {
     const currVersion = commandVersion.currentVersion || '';
     const lastVersion = commandVersion.latestVersion || '';
     const env = commandVersion.env || '';
-    if (currVersion !== lastVersion) {
+    if ((0, utils_1.isVersionNewer)(lastVersion, currVersion)) {
         const platform = (0, utils_1.getPlatform)();
         const isMac = platform === 'darwin';
         const isWin = platform === 'win32';

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/index.js

@@ -16,7 +16,14 @@ process.title = 'bdy';
 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/logger.js

@@ -64,7 +64,13 @@ class Logger {
             this.logPath = (0, path_1.resolve)(this.rootPath, 'cli.log');
             this.log1Path = (0, path_1.resolve)(this.rootPath, 'cli.1.log');
             try {
-                this.logStream = fs_1.default.openSync(this.logPath, 'w');
+                // 'a', not 'w': every start used to truncate the log, so an agent that died and was
+                // restarted by its service manager came back having erased the only record of why -
+                // and a crash loop leaves nothing at all. Append also survives an external truncation
+                // (rotation, someone clearing the file) without the zero-padding a tracked write offset
+                // produces, because O_APPEND puts every write at the current end of the file.
+                // checkLogSize() below still bounds it at 5 MB.
+                this.logStream = fs_1.default.openSync(this.logPath, 'a');
             }
             catch {
                 // A log we cannot open is not a reason to fail the command - a read-only home, a full

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

@@ -136,9 +136,18 @@ class Output {
     }
     // Payload output (command results, logs, JSON): bypasses terminal-kit,
     // whose printf-style formatting and ^-markup corrupt data containing
-    // % or ^ sequences.
-    static data(txt) {
-        process.stdout.write(`${txt}\n`);
+    // % 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`);