Fix literal \n in CLI-mode safeoutputs string args not becoming newlines

actions/setup/js/mcp_cli_bridge.cjs

@@ -778,6 +778,40 @@ function resolveSchemaPropertyKey(key, schemaProperties, normalizedSchemaKeyMap,
   return normalizedSchemaKeyMap.get(normalized) || key;
 }
 
+/**
+ * Unescape standard escape sequences in a CLI string argument.
+ *
+ * Converts the same escape sequences that JSON string parsing recognises so
+ * that agents can write `--body "Hello\nWorld"` and get an actual newline,
+ * matching the behaviour of JSON stdin mode where `JSON.parse` handles `\n`.
+ *
+ * Supported sequences:
+ *   `\n`  → newline
+ *   `\t`  → tab
+ *   `\r`  → carriage return
+ *   `\\`  → single backslash
+ *   Any other `\X` is left unchanged (the backslash is preserved).
+ *
+ * @param {string} str - Raw CLI string argument
+ * @returns {string} String with escape sequences replaced by their literal characters
+ */
+function unescapeCliStringArg(str) {
+  return str.replace(/\\([\s\S])/g, (match, char) => {
+    switch (char) {
+      case "n":
+        return "\n";
+      case "t":
+        return "\t";
+      case "r":
+        return "\r";
+      case "\\":
+        return "\\";
+      default:
+        return match;
+    }
+  });
+}
+
 /**
  * Parse and coerce a CLI argument value based on the MCP tool schema property type.
  *
@@ -857,6 +891,14 @@ function coerceToolArgValue(key, rawValue, schemaProperty, existingValue, allowN
     }
   }
 
+  // Unescape standard escape sequences in string-typed values so that agents
+  // can write `--body "Hello\nWorld"` and get an actual newline.  This mirrors
+  // the behaviour of JSON stdin mode where JSON.parse interprets `\n` as a
+  // newline character.
+  if (types.includes("string")) {
+    return unescapeCliStringArg(rawValue);
+  }
+
   // When schema metadata is unavailable (e.g. empty tools cache), apply
   // conservative numeric coercion fallback for CLI ergonomics.
   if (allowNumericFallback && types.length === 0) {
@@ -1376,6 +1418,7 @@ if (require.main === module) {
 module.exports = {
   parseToolArgs,
   coerceToolArgValue,
+  unescapeCliStringArg,
   extractJSONRPCMessages,
   renderProgressMessages,
   formatResponse,

actions/setup/js/mcp_cli_bridge.test.cjs

@@ -3,7 +3,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 
-import { ensureSafeOutputsTools, formatResponse, getToolCallTimeoutMs, hasStdinJsonPayload, parseToolArgs, readStdinSync, shouldShowToolHelpForEmptyArgs, showHelp, showToolHelp, writeStdoutAndFlush } from "./mcp_cli_bridge.cjs";
+import { ensureSafeOutputsTools, formatResponse, getToolCallTimeoutMs, hasStdinJsonPayload, parseToolArgs, readStdinSync, shouldShowToolHelpForEmptyArgs, showHelp, showToolHelp, unescapeCliStringArg, writeStdoutAndFlush } from "./mcp_cli_bridge.cjs";
 
 describe("mcp_cli_bridge.cjs", () => {
   let originalCore;
@@ -750,6 +750,80 @@ describe("mcp_cli_bridge.cjs", () => {
     });
   });
 
+  describe("unescapeCliStringArg", () => {
+    it("converts \\n to an actual newline", () => {
+      expect(unescapeCliStringArg("Hello\\nWorld")).toBe("Hello\nWorld");
+    });
+
+    it("converts \\t to a tab character", () => {
+      expect(unescapeCliStringArg("col1\\tcol2")).toBe("col1\tcol2");
+    });
+
+    it("converts \\r to a carriage return", () => {
+      expect(unescapeCliStringArg("line1\\rline2")).toBe("line1\rline2");
+    });
+
+    it("converts \\\\ to a single backslash", () => {
+      expect(unescapeCliStringArg("path\\\\to\\\\file")).toBe("path\\to\\file");
+    });
+
+    it("converts \\\\n to a literal backslash followed by n (not a newline)", () => {
+      // \\n in the CLI arg should become \n (backslash + n), not a newline
+      expect(unescapeCliStringArg("Hello\\\\nWorld")).toBe("Hello\\nWorld");
+    });
+
+    it("leaves unknown escape sequences unchanged", () => {
+      expect(unescapeCliStringArg("value\\xunknown")).toBe("value\\xunknown");
+    });
+
+    it("handles multiple escape sequences in the same string", () => {
+      expect(unescapeCliStringArg("line1\\nline2\\nline3")).toBe("line1\nline2\nline3");
+    });
+
+    it("returns a plain string unchanged when no escape sequences are present", () => {
+      expect(unescapeCliStringArg("no escapes here")).toBe("no escapes here");
+    });
+  });
+
+  describe("parseToolArgs — string escape unescaping", () => {
+    it("unescapes \\n in string-typed CLI flag arguments", () => {
+      const schemaProperties = { body: { type: "string" } };
+      const { args } = parseToolArgs(["--body", "Hello\\nWorld"], schemaProperties);
+      expect(args).toEqual({ body: "Hello\nWorld" });
+    });
+
+    it("unescapes \\n in string-typed --key=value arguments", () => {
+      const schemaProperties = { body: { type: "string" } };
+      const { args } = parseToolArgs(["--body=Hello\\nWorld"], schemaProperties);
+      expect(args).toEqual({ body: "Hello\nWorld" });
+    });
+
+    it("unescapes \\n when type is ['string', 'null']", () => {
+      const schemaProperties = { body: { type: ["string", "null"] } };
+      const { args } = parseToolArgs(["--body", "line1\\nline2"], schemaProperties);
+      expect(args).toEqual({ body: "line1\nline2" });
+    });
+
+    it("does not unescape \\n when schema type is integer", () => {
+      // A value with \n for an integer field should not be unescaped (it would fail coercion anyway)
+      const schemaProperties = { count: { type: "integer" } };
+      const { args } = parseToolArgs(["--count", "5\\n"], schemaProperties);
+      // "5\n" is not a valid integer, falls through to rawValue
+      expect(args).toEqual({ count: "5\\n" });
+    });
+
+    it("produces actual newlines matching JSON stdin mode behaviour", () => {
+      // Verify that --body "title\n\nbody" (CLI flags) gives the same result as
+      // JSON stdin with {"body":"title\n\nbody"}
+      const schemaProperties = { body: { type: "string" } };
+
+      const { args: cliArgs } = parseToolArgs(["--body", "title\\n\\nbody"], schemaProperties);
+      const { args: jsonArgs } = parseToolArgs(["."], schemaProperties, '{"body":"title\\n\\nbody"}');
+
+      expect(cliArgs).toEqual(jsonArgs);
+    });
+  });
+
   describe("writeStdoutAndFlush", () => {
     it("resolves immediately when stdout.write returns true (no backpressure)", async () => {
       // The beforeEach mock captures chunks and returns true (no backpressure).