More commands

Author: cramforce

AGENTS.md

@@ -8,6 +8,16 @@ Usage: pnpm dev:exec '<bash script>'
        cat script.sh | pnpm dev:exec
 ```
 
+**Important**: When using `pnpm dev:exec` with command-line arguments, pnpm converts single quotes to double quotes, which causes shell variables like `$?` to be expanded by the host shell before reaching BashEnv. To test scripts containing `$?` or other shell variables, use stdin instead:
+
+```bash
+# WRONG - $? gets expanded by host shell to 0:
+pnpm dev:exec 'false; echo $?'
+
+# CORRECT - use stdin to avoid shell expansion:
+echo 'false; echo $?' | pnpm dev:exec
+```
+
 - Install packages via pnpm rather than editing package.json directly
 - Bias towards making new test files that are roughly logically grouped rather than letting test files gets too large. Try to stay below 300 lines. Prefer making a new file when you want to add a `describe()`
 - Prefer asserting the full STDOUT/STDERR output rather than using to.contain or to.not.contain
@@ -24,3 +34,11 @@ Usage: pnpm dev:exec '<bash script>'
 - Always make sure to build before using dist
 - Biome rules often have the same name as eslint rules (if you are lookinf for one)
 - Error / show usage on unknown flags in commands and built-ins (unless real bash also ignores)
+- Dependencies that use wasm are not allowed. Binary npm packages are fine
+
+## Commands
+
+- Must have usage statement
+- Must error on unknown options (unless bash ignores them)
+- Must have extensive unit tests collocated with the command
+- Should have comparison tests if there is doubt about behavior

package.json

@@ -41,6 +41,7 @@
     "vitest": "^4.0.16"
   },
   "dependencies": {
+    "diff": "^8.0.2",
     "minimatch": "^10.1.1",
     "sprintf-js": "^1.1.3"
   }

pnpm-lock.yaml

@@ -76,8 +76,10 @@ export class BashEnv {
       lastExitCode: 0,
       options: {
         errexit: false,
+        pipefail: false,
       },
       inCondition: false,
+      loopDepth: 0,
     };
 
     // Create essential directories for VirtualFs (only for default layout)

src/BashEnv.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it } from "vitest";
+import { BashEnv } from "../../BashEnv.js";
+
+describe("base64", () => {
+  describe("encoding", () => {
+    it("should encode string from stdin", async () => {
+      const env = new BashEnv();
+      const result = await env.exec('echo -n "hello" | base64');
+      expect(result.stdout).toBe("aGVsbG8=\n");
+      expect(result.stderr).toBe("");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should encode string with newline", async () => {
+      const env = new BashEnv();
+      const result = await env.exec('echo "hello" | base64');
+      expect(result.stdout).toBe("aGVsbG8K\n");
+      expect(result.stderr).toBe("");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should encode file contents", async () => {
+      const env = new BashEnv({
+        files: { "/test.txt": "hello" },
+      });
+      const result = await env.exec("base64 /test.txt");
+      expect(result.stdout).toBe("aGVsbG8=\n");
+      expect(result.stderr).toBe("");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should wrap lines at 76 characters by default", async () => {
+      const env = new BashEnv();
+      // Long input that will produce > 76 chars of base64
+      const result = await env.exec(
+        'echo -n "This is a very long string that will definitely produce more than 76 characters of base64 output" | base64',
+      );
+      const lines = result.stdout.split("\n").filter((l) => l);
+      expect(lines[0].length).toBeLessThanOrEqual(76);
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should not wrap with -w 0", async () => {
+      const env = new BashEnv();
+      const result = await env.exec(
+        'echo -n "This is a very long string that will definitely produce more than 76 characters of base64 output" | base64 -w 0',
+      );
+      // Should be single line (no newline wrapping, just trailing newline)
+      expect(result.stdout).not.toContain("\n\n");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should wrap at custom width", async () => {
+      const env = new BashEnv();
+      const result = await env.exec(
+        'echo -n "hello world test" | base64 -w 10',
+      );
+      const lines = result.stdout.split("\n").filter((l) => l);
+      for (const line of lines.slice(0, -1)) {
+        expect(line.length).toBe(10);
+      }
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("decoding", () => {
+    it("should decode base64 with -d", async () => {
+      const env = new BashEnv();
+      const result = await env.exec('echo "aGVsbG8=" | base64 -d');
+      expect(result.stdout).toBe("hello");
+      expect(result.stderr).toBe("");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should decode base64 with --decode", async () => {
+      const env = new BashEnv();
+      const result = await env.exec('echo "aGVsbG8=" | base64 --decode');
+      expect(result.stdout).toBe("hello");
+      expect(result.stderr).toBe("");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should decode base64 from file", async () => {
+      const env = new BashEnv({
+        files: { "/encoded.txt": "aGVsbG8gd29ybGQ=" },
+      });
+      const result = await env.exec("base64 -d /encoded.txt");
+      expect(result.stdout).toBe("hello world");
+      expect(result.stderr).toBe("");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should ignore whitespace when decoding", async () => {
+      const env = new BashEnv();
+      const result = await env.exec('echo "aGVs\nbG8=" | base64 -d');
+      expect(result.stdout).toBe("hello");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should roundtrip encode then decode", async () => {
+      const env = new BashEnv();
+      const result = await env.exec(
+        'echo -n "test data 123" | base64 | base64 -d',
+      );
+      expect(result.stdout).toBe("test data 123");
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("error handling", () => {
+    it("should error on missing file", async () => {
+      const env = new BashEnv();
+      const result = await env.exec("base64 /nonexistent.txt");
+      expect(result.stdout).toBe("");
+      expect(result.stderr).toBe(
+        "base64: /nonexistent.txt: No such file or directory\n",
+      );
+      expect(result.exitCode).toBe(1);
+    });
+
+    it("should error on unknown option", async () => {
+      const env = new BashEnv();
+      const result = await env.exec("base64 --unknown");
+      expect(result.stderr).toContain("unrecognized option");
+      expect(result.exitCode).toBe(1);
+    });
+
+    it("should error on unknown short option", async () => {
+      const env = new BashEnv();
+      const result = await env.exec("base64 -z");
+      expect(result.stderr).toContain("invalid option");
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("help", () => {
+    it("should show help with --help", async () => {
+      const env = new BashEnv();
+      const result = await env.exec("base64 --help");
+      expect(result.stdout).toContain("base64");
+      expect(result.stdout).toContain("decode");
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("stdin placeholder", () => {
+    it("should read from stdin with -", async () => {
+      const env = new BashEnv();
+      const result = await env.exec('echo -n "test" | base64 -');
+      expect(result.stdout).toBe("dGVzdA==\n");
+      expect(result.exitCode).toBe(0);
+    });
+  });
+});

src/commands/base64/base64.test.ts

@@ -0,0 +1,90 @@
+/**
+ * base64 - Encode or decode base64
+ */
+
+import type { Command, CommandContext, ExecResult } from "../../types.js";
+import { hasHelpFlag, showHelp, unknownOption } from "../help.js";
+
+const base64Help = {
+  name: "base64",
+  summary: "base64 encode/decode data and print to standard output",
+  usage: "base64 [OPTION]... [FILE]",
+  options: [
+    "-d, --decode    decode data",
+    "-w, --wrap=COLS wrap encoded lines after COLS character (default 76, 0 to disable)",
+    "    --help      display this help and exit",
+  ],
+};
+
+export const base64Command: Command = {
+  name: "base64",
+
+  async execute(args: string[], ctx: CommandContext): Promise<ExecResult> {
+    if (hasHelpFlag(args)) {
+      return showHelp(base64Help);
+    }
+
+    let decode = false;
+    let wrapCols = 76;
+    const files: string[] = [];
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "-d" || arg === "--decode") {
+        decode = true;
+      } else if (arg === "-w" || arg === "--wrap") {
+        wrapCols = Number.parseInt(args[++i] ?? "76", 10) || 0;
+      } else if (arg.startsWith("--wrap=")) {
+        wrapCols = Number.parseInt(arg.slice(7), 10) || 0;
+      } else if (arg.startsWith("-w")) {
+        wrapCols = Number.parseInt(arg.slice(2), 10) || 0;
+      } else if (arg === "-") {
+        files.push("-");
+      } else if (arg.startsWith("--")) {
+        return unknownOption("base64", arg);
+      } else if (arg.startsWith("-")) {
+        for (const c of arg.slice(1)) {
+          if (c === "d") decode = true;
+          else return unknownOption("base64", `-${c}`);
+        }
+      } else {
+        files.push(arg);
+      }
+    }
+
+    let input: string;
+    if (files.length === 0 || (files.length === 1 && files[0] === "-")) {
+      input = ctx.stdin;
+    } else {
+      try {
+        const filePath = ctx.fs.resolvePath(ctx.cwd, files[0]);
+        input = await ctx.fs.readFile(filePath);
+      } catch {
+        return {
+          stdout: "",
+          stderr: `base64: ${files[0]}: No such file or directory\n`,
+          exitCode: 1,
+        };
+      }
+    }
+
+    try {
+      if (decode) {
+        const cleaned = input.replace(/\s/g, "");
+        const decoded = Buffer.from(cleaned, "base64").toString("utf-8");
+        return { stdout: decoded, stderr: "", exitCode: 0 };
+      }
+      let encoded = Buffer.from(input).toString("base64");
+      if (wrapCols > 0) {
+        const lines: string[] = [];
+        for (let i = 0; i < encoded.length; i += wrapCols) {
+          lines.push(encoded.slice(i, i + wrapCols));
+        }
+        encoded = lines.join("\n") + (encoded.length > 0 ? "\n" : "");
+      }
+      return { stdout: encoded, stderr: "", exitCode: 0 };
+    } catch {
+      return { stdout: "", stderr: "base64: invalid input\n", exitCode: 1 };
+    }
+  },
+};