Substantially improved binary support across commands and test coverage

Author: cramforce

src/commands/base64/base64.binary.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import { Bash } from "../../Bash.js";
+
+describe("base64 with binary data", () => {
+  describe("binary file encoding", () => {
+    it("should encode binary file with high bytes", async () => {
+      const env = new Bash({
+        files: {
+          "/binary.bin": new Uint8Array([0x80, 0x90, 0xa0, 0xb0, 0xff]),
+        },
+      });
+
+      const result = await env.exec("base64 /binary.bin");
+      expect(result.exitCode).toBe(0);
+      // Verify it produces valid base64 output
+      expect(result.stdout.trim()).toMatch(/^[A-Za-z0-9+/]+=*$/);
+    });
+
+    it("should encode and decode file with null bytes", async () => {
+      const env = new Bash({
+        files: {
+          "/nulls.bin": new Uint8Array([0x41, 0x00, 0x42, 0x00, 0x43]),
+        },
+      });
+
+      await env.exec("base64 /nulls.bin > /encoded.txt");
+      const decodeResult = await env.exec("base64 -d /encoded.txt");
+
+      expect(decodeResult.stdout).toBe("A\0B\0C");
+    });
+
+    it("should encode and decode file with all byte values", async () => {
+      const env = new Bash({
+        files: {
+          "/allbytes.bin": new Uint8Array(
+            Array.from({ length: 256 }, (_, i) => i),
+          ),
+        },
+      });
+
+      await env.exec("base64 /allbytes.bin > /encoded.txt");
+      const decodeResult = await env.exec("base64 -d /encoded.txt");
+
+      expect(decodeResult.stdout.length).toBe(256);
+      for (let i = 0; i < 256; i++) {
+        expect(decodeResult.stdout.charCodeAt(i)).toBe(i);
+      }
+    });
+  });
+
+  describe("binary stdin piping", () => {
+    it("should encode binary data from stdin", async () => {
+      const env = new Bash({
+        files: {
+          "/binary.bin": new Uint8Array([0x80, 0xff, 0x90, 0xab]),
+        },
+      });
+
+      const result = await env.exec("cat /binary.bin | base64");
+      // Verify it encodes without error
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.trim().length).toBeGreaterThan(0);
+    });
+
+    it("should round-trip binary data through stdin", async () => {
+      const env = new Bash({
+        files: {
+          "/binary.bin": new Uint8Array([0x80, 0xff, 0x90, 0xab, 0xcd]),
+        },
+      });
+
+      await env.exec("cat /binary.bin | base64 > /encoded.txt");
+      const result = await env.exec("base64 -d /encoded.txt");
+
+      expect(result.stdout.charCodeAt(0)).toBe(0x80);
+      expect(result.stdout.charCodeAt(1)).toBe(0xff);
+      expect(result.stdout.charCodeAt(2)).toBe(0x90);
+      expect(result.stdout.charCodeAt(3)).toBe(0xab);
+      expect(result.stdout.charCodeAt(4)).toBe(0xcd);
+    });
+
+    it("should decode base64 from stdin", async () => {
+      const env = new Bash({
+        files: {
+          // "Hello" in base64
+          "/encoded.txt": "SGVsbG8=\n",
+        },
+      });
+
+      const result = await env.exec("cat /encoded.txt | base64 -d");
+      expect(result.stdout).toBe("Hello");
+    });
+
+    it("should decode valid base64 from stdin", async () => {
+      const env = new Bash({
+        files: {
+          // "ABC" in base64
+          "/encoded.txt": "QUJD\n",
+        },
+      });
+
+      const result = await env.exec("cat /encoded.txt | base64 -d");
+      expect(result.stdout).toBe("ABC");
+    });
+  });
+
+  describe("round-trip integrity", () => {
+    it("should round-trip text content", async () => {
+      const env = new Bash({
+        files: {
+          "/data.txt": "Hello World 123",
+        },
+      });
+
+      await env.exec("base64 /data.txt > /encoded.txt");
+      const result = await env.exec("base64 -d /encoded.txt");
+
+      expect(result.stdout).toBe("Hello World 123");
+    });
+
+    it("should round-trip via stdin", async () => {
+      const env = new Bash({
+        files: {
+          "/data.txt": "test content",
+        },
+      });
+
+      await env.exec("cat /data.txt | base64 > /encoded.txt");
+      const result = await env.exec("base64 -d /encoded.txt");
+
+      expect(result.stdout).toBe("test content");
+    });
+  });
+});

src/commands/base64/base64.ts

@@ -30,14 +30,19 @@ async function readBinary(
 ): Promise<{ ok: true; data: Uint8Array } | { ok: false; error: ExecResult }> {
   // No files - read from stdin
   if (files.length === 0 || (files.length === 1 && files[0] === "-")) {
-    return { ok: true, data: new TextEncoder().encode(ctx.stdin) };
+    // Convert binary string directly to bytes without UTF-8 re-encoding
+    return {
+      ok: true,
+      data: Uint8Array.from(ctx.stdin, (c) => c.charCodeAt(0)),
+    };
   }
 
   // Read and concatenate all files as binary
   const chunks: Uint8Array[] = [];
   for (const file of files) {
     if (file === "-") {
-      chunks.push(new TextEncoder().encode(ctx.stdin));
+      // Convert binary string directly to bytes without UTF-8 re-encoding
+      chunks.push(Uint8Array.from(ctx.stdin, (c) => c.charCodeAt(0)));
       continue;
     }
     try {
@@ -88,11 +93,11 @@ export const base64Command: Command = {
         // For decoding, read as text and strip whitespace
         const readResult = await readBinary(ctx, files, "base64");
         if (!readResult.ok) return readResult.error;
-        const input = new TextDecoder().decode(readResult.data);
+        // Use binary string (latin1) to preserve bytes for input
+        const input = String.fromCharCode(...readResult.data);
         const cleaned = input.replace(/\s/g, "");
-        // Decode base64 to bytes, then to UTF-8 string for output
-        const bytes = Uint8Array.from(atob(cleaned), (c) => c.charCodeAt(0));
-        const decoded = new TextDecoder().decode(bytes);
+        // Decode base64 to binary string (each char code = byte value)
+        const decoded = atob(cleaned);
         return { stdout: decoded, stderr: "", exitCode: 0 };
       }
 

src/commands/diff/diff.binary.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { Bash } from "../../Bash.js";
+
+describe("diff with binary data", () => {
+  describe("binary file comparison", () => {
+    it("should detect identical binary files", async () => {
+      const env = new Bash({
+        files: {
+          "/a.bin": new Uint8Array([0x80, 0x90, 0xa0, 0xb0, 0xff]),
+          "/b.bin": new Uint8Array([0x80, 0x90, 0xa0, 0xb0, 0xff]),
+        },
+      });
+
+      const result = await env.exec("diff /a.bin /b.bin");
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe("");
+    });
+
+    it("should handle files with null bytes - identical", async () => {
+      const env = new Bash({
+        files: {
+          "/a.bin": new Uint8Array([0x41, 0x00, 0x42]),
+          "/b.bin": new Uint8Array([0x41, 0x00, 0x42]),
+        },
+      });
+
+      const result = await env.exec("diff /a.bin /b.bin");
+
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should detect difference in files with null bytes", async () => {
+      const env = new Bash({
+        files: {
+          "/a.bin": new Uint8Array([0x41, 0x00, 0x42]),
+          "/b.bin": new Uint8Array([0x41, 0x00, 0x43]),
+        },
+      });
+
+      const result = await env.exec("diff /a.bin /b.bin");
+
+      expect(result.exitCode).toBe(1);
+    });
+
+    it("should detect difference in text files with high bytes", async () => {
+      const env = new Bash({
+        files: {
+          // Single line of text with high bytes
+          "/a.txt": "hello\x80world\n",
+          "/b.txt": "hello\x81world\n",
+        },
+      });
+
+      const result = await env.exec("diff /a.txt /b.txt");
+
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("binary stdin comparison", () => {
+    it("should detect difference with binary stdin", async () => {
+      const env = new Bash({
+        files: {
+          "/a.bin": new Uint8Array([0x80, 0x91, 0xa0]),
+          "/b.bin": new Uint8Array([0x80, 0x90, 0xa0]),
+        },
+      });
+
+      const result = await env.exec("cat /a.bin | diff - /b.bin");
+
+      expect(result.exitCode).toBe(1);
+    });
+  });
+});

src/commands/echo/echo.binary.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import { Bash } from "../../Bash.js";
+
+describe("echo with binary data", () => {
+  describe("hex escape sequences with -e", () => {
+    it("should output binary bytes via hex escapes", async () => {
+      const env = new Bash();
+
+      const result = await env.exec("echo -ne '\\x80\\x90\\xa0\\xb0\\xff'");
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.length).toBe(5);
+      expect(result.stdout.charCodeAt(0)).toBe(0x80);
+      expect(result.stdout.charCodeAt(1)).toBe(0x90);
+      expect(result.stdout.charCodeAt(2)).toBe(0xa0);
+      expect(result.stdout.charCodeAt(3)).toBe(0xb0);
+      expect(result.stdout.charCodeAt(4)).toBe(0xff);
+    });
+
+    it("should output null bytes via hex escapes", async () => {
+      const env = new Bash();
+
+      const result = await env.exec("echo -ne 'A\\x00B\\x00C'");
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe("A\0B\0C");
+    });
+
+    it("should redirect binary hex output to file", async () => {
+      const env = new Bash();
+
+      await env.exec("echo -ne '\\x80\\xff\\x90' > /binary.bin");
+      const result = await env.exec("cat /binary.bin");
+
+      expect(result.stdout.charCodeAt(0)).toBe(0x80);
+      expect(result.stdout.charCodeAt(1)).toBe(0xff);
+      expect(result.stdout.charCodeAt(2)).toBe(0x90);
+    });
+  });
+
+  describe("octal escape sequences with -e", () => {
+    it("should output binary bytes via octal escapes", async () => {
+      const env = new Bash();
+
+      const result = await env.exec("echo -ne '\\0200\\0220\\0240'");
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.length).toBe(3);
+      expect(result.stdout.charCodeAt(0)).toBe(0o200); // 128
+      expect(result.stdout.charCodeAt(1)).toBe(0o220); // 144
+      expect(result.stdout.charCodeAt(2)).toBe(0o240); // 160
+    });
+
+    it("should redirect binary octal output to file", async () => {
+      const env = new Bash();
+
+      await env.exec("echo -ne '\\0200\\0377' > /binary.bin");
+      const result = await env.exec("cat /binary.bin");
+
+      expect(result.stdout.charCodeAt(0)).toBe(0o200); // 128
+      expect(result.stdout.charCodeAt(1)).toBe(0o377); // 255
+    });
+  });
+
+  describe("round-trip through pipe", () => {
+    it("should preserve binary data through cat pipe", async () => {
+      const env = new Bash();
+
+      await env.exec("echo -ne '\\x80\\xff\\x00\\x90' > /input.bin");
+      await env.exec("cat /input.bin > /output.bin");
+      const result = await env.exec("cat /output.bin");
+
+      expect(result.stdout.length).toBe(4);
+      expect(result.stdout.charCodeAt(0)).toBe(0x80);
+      expect(result.stdout.charCodeAt(1)).toBe(0xff);
+      expect(result.stdout.charCodeAt(2)).toBe(0x00);
+      expect(result.stdout.charCodeAt(3)).toBe(0x90);
+    });
+  });
+});