@effected/cli 0.16.0 → 0.16.1

package/Doc.js

@@ -463,8 +463,9 @@ var Doc = class {
 	* and every other renderer writes nothing.
 	*
 	* @remarks
-	* It is the kit's own command, so `githubLog` does not neutralize it; its message and properties are escaped, so
-	* no text in them can end the command or start another. It is a command where a line starts: at the top level, as a
+	* It is the kit's own command, so `githubLog` does not neutralize the command itself; its message and properties are
+	* escaped, so no text in them can end the command or start another, and a `##[` in its message, title or file gets
+	* a braille pattern blank (U+2800) before the `[`, as in plain text. It is a command where a line starts: at the top level, as a
 	* top-level section's child, or as a direct child of a group's body. Nested deeper, it is dropped.
 	*
 	* @param options - the level, and the optional file, position and title

package/Render.js

@@ -232,7 +232,8 @@ var Render = class {
 	* body, `::endgroup::`. An annotation is a command at the top level, as a top-level section's child, and as a direct
 	* child of a group's body; anywhere deeper (inside a list, a callout, or a section within a group) it is nothing,
 	* as in plain. Its message and properties are escaped, so no text can end
-	* the command or start another, and the kit's own command is never neutralized. That is a top-level collapsible, or one that is a direct child of a
+	* the command or start another, and the kit's own command is never neutralized, though a `##[` in its message,
+	* title or file is. That is a top-level collapsible, or one that is a direct child of a
 	* top-level section. GitHub does not nest groups, so a collapsible inside a group, or inside a list or callout
 	* (where it would not start a line), keeps plain's rendering: its title on a line and its body indented.
 	*
@@ -241,7 +242,7 @@ var Render = class {
 	* do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a braille pattern blank (U+2800) in
 	* front, which the runner neither trims nor skips, and every `##[` gets one before the `[`. The text is
 	* otherwise unchanged. A
-	* group's title is a command's data, so its `%`, CR and LF are escaped. Lines are split at CR, LF and CRLF before
+	* group's title is a command's data, so its `%`, CR and LF are escaped and a `##[` in it is neutralized. Lines are split at CR, LF and CRLF before
 	* that check, as the runner splits them. There is no ANSI and `paint` and `link` are never called, and the audience
 	* is treated as `agent`, as `plain` does.
 	*

package/index.d.ts

@@ -1382,8 +1382,9 @@ export declare class Doc {
    * and every other renderer writes nothing.
    *
    * @remarks
-   * It is the kit's own command, so `githubLog` does not neutralize it; its message and properties are escaped, so
-   * no text in them can end the command or start another. It is a command where a line starts: at the top level, as a
+   * It is the kit's own command, so `githubLog` does not neutralize the command itself; its message and properties are
+   * escaped, so no text in them can end the command or start another, and a `##[` in its message, title or file gets
+   * a braille pattern blank (U+2800) before the `[`, as in plain text. It is a command where a line starts: at the top level, as a
    * top-level section's child, or as a direct child of a group's body. Nested deeper, it is dropped.
    *
    * @param options - the level, and the optional file, position and title
@@ -3474,7 +3475,8 @@ export declare class Render {
    * body, `::endgroup::`. An annotation is a command at the top level, as a top-level section's child, and as a direct
    * child of a group's body; anywhere deeper (inside a list, a callout, or a section within a group) it is nothing,
    * as in plain. Its message and properties are escaped, so no text can end
-   * the command or start another, and the kit's own command is never neutralized. That is a top-level collapsible, or one that is a direct child of a
+   * the command or start another, and the kit's own command is never neutralized, though a `##[` in its message,
+   * title or file is. That is a top-level collapsible, or one that is a direct child of a
    * top-level section. GitHub does not nest groups, so a collapsible inside a group, or inside a list or callout
    * (where it would not start a line), keeps plain's rendering: its title on a line and its body indented.
    *
@@ -3483,7 +3485,7 @@ export declare class Render {
    * do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a braille pattern blank (U+2800) in
    * front, which the runner neither trims nor skips, and every `##[` gets one before the `[`. The text is
    * otherwise unchanged. A
-   * group's title is a command's data, so its `%`, CR and LF are escaped. Lines are split at CR, LF and CRLF before
+   * group's title is a command's data, so its `%`, CR and LF are escaped and a `##[` in it is neutralized. Lines are split at CR, LF and CRLF before
    * that check, as the runner splits them. There is no ANSI and `paint` and `link` are never called, and the audience
    * is treated as `agent`, as `plain` does.
    *

package/internal/renderGithubLog.js

@@ -5,10 +5,22 @@ import { CommandNeutralizer, WorkflowCommand } from "@effected/github-commands";
 //#region src/internal/renderGithubLog.ts
 /** Plain lines, neutralized; a block that draws nothing, such as an empty table, gives no line at all. */
 const plainLines = (blocks, ctx) => renderPlainLines(blocks, ctx).flatMap((line) => CommandNeutralizer.lines(line));
-/** An annotation as the kit's own command, on the trusted path: escaped by `WorkflowCommand`, never neutralized. */
-const annotationLine = (block) => WorkflowCommand[block.level](sanitize(block.message), {
-	...block.title === void 0 ? {} : { title: sanitize(block.title) },
-	...block.file === void 0 ? {} : { file: sanitize(block.file) },
+/**
+* A command's data, with every `##[` neutralized and its line breaks kept as they were. `WorkflowCommand` escapes the
+* breaks, so the command stays one line, but the runner's legacy parser reads `##[` ANYWHERE in a line, including in
+* a command's message and property values (it is tried when the V2 parser rejects the line), so each `##[` gets the
+* neutralizer's marker before its `[`. The V2 rule does not apply: no part of the data starts a line of the log, so
+* each part is neutralized behind a one-character lead that cannot start a command and is cut off again, which keeps
+* a part that begins `::` as it was. The command itself is not neutralized: only the data that goes into it.
+*/
+const commandData = (text) => text.split(/(\r\n|\r|\n)/).map((part, index) => index % 2 === 0 ? CommandNeutralizer.text(`.${part}`).slice(1) : part).join("");
+/**
+* An annotation as the kit's own command, on the trusted path: escaped by `WorkflowCommand`, and its message, title
+* and file neutralized as data (the line and the columns are numbers, which carry nothing).
+*/
+const annotationLine = (block) => WorkflowCommand[block.level](commandData(sanitize(block.message)), {
+	...block.title === void 0 ? {} : { title: commandData(sanitize(block.title)) },
+	...block.file === void 0 ? {} : { file: commandData(sanitize(block.file)) },
 	...block.line === void 0 ? {} : { startLine: block.line },
 	...block.endLine === void 0 ? {} : { endLine: block.endLine },
 	...block.col === void 0 ? {} : { startColumn: block.col },
@@ -20,7 +32,7 @@ const blockLines = (block, ctx) => {
 	switch (block._tag) {
 		case "Annotation": return [annotationLine(block)];
 		case "Collapsible": {
-			const title = plainInline(block.title, ctx).map((span) => span.text).join("");
+			const title = commandData(plainInline(block.title, ctx).map((span) => span.text).join(""));
 			return [
 				WorkflowCommand.group(title),
 				...bodyLines(block.body, ctx),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/cli",
-	"version": "0.16.0",
+	"version": "0.16.1",
 	"private": false,
 	"description": "The presentation boundary of an effect/cli program: audience-aware output, a document IR and renderers, editor links, failure reports and logging, plus opt-in Ink screens, widgets and a live view",
 	"keywords": [
@@ -57,11 +57,11 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/github-commands": "^0.2.0"
+		"@effected/github-commands": "^0.2.1"
 	},
 	"peerDependencies": {
 		"@effected/config-file": "^0.14.2",
-		"@effected/env": "^0.1.0",
+		"@effected/env": "^0.1.1",
 		"@effected/glob": "^0.10.0",
 		"@effected/walker": "^0.15.0",
 		"@types/react": "^19.3.0",

package/ui/testing/fakeStreams.js

@@ -1,10 +1,36 @@
 import { PassThrough, Writable } from "node:stream";
 
 //#region src/ui/testing/fakeStreams.ts
+/** The hide-cursor escape `cli-cursor` writes to a TTY stream as it arms the restore. */
+const HIDE_CURSOR = `${String.fromCharCode(27)}[?25l`;
+/** A cursor-show escape in a listener's source, as `restore-cursor` writes it (`'\u001B[?25h'`) or as the raw byte. */
+const CURSOR_SHOW = /\[\?25h/;
+/**
+* Disarm the real terminal's cursor restore that a fake TTY arms, so no byte of a run on the fakes reaches the
+* process's own streams (#983). The fake streams call it as the hide escape is written to them.
+*
+* @remarks
+* Ink's frame writer hides the cursor through `cli-cursor` on its first render, and `cli-cursor` does it only for a
+* stream that says it is a TTY, which the fakes do. Hiding it also arms `restore-cursor`, once per loaded copy of it
+* (once per test file where the runner isolates modules): a `signal-exit` hook (`alwaysLast`, so on the `afterexit`
+* event) that writes the cursor-show escape to the REAL `process.stderr` when the process exits or is signalled,
+* whatever stream Ink was given and whether or not stderr is a terminal. Nothing on the fakes hid the real cursor, so
+* that restore is only ever a stray byte in the test runner's output: this removes every `afterexit` listener that
+* writes a cursor-show escape, right after the copy that armed it wrote its hide escape. The emitter is `signal-exit` 3's process-wide one, the version `restore-cursor` 4
+* (the one Ink 8's `cli-cursor` takes) loads; without one there is nothing to disarm.
+*
+* The one read of `process` in the testing fakes, under the process-streams licence: it touches no stream.
+*/
+const disarmCursorRestore = () => {
+	const emitter = process.__signal_exit_emitter__;
+	if (emitter === void 0) return;
+	for (const listener of emitter.listeners("afterexit")) if (CURSOR_SHOW.test(String(listener))) emitter.removeListener("afterexit", listener);
+};
 const capture = (columns, rows, both, onWrite) => {
 	const chunks = [];
 	const stream = new Writable({ write(chunk, _encoding, callback) {
 		const text = chunk.toString();
+		if (text.includes(HIDE_CURSOR)) disarmCursorRestore();
 		chunks.push(text);
 		both.push(text);
 		onWrite?.(text);