binary

Author: cramforce

PROJECT.md

@@ -195,3 +195,6 @@ xargs — build argument lists
 ## Implementation phase 12
 
 - Lazy load commands via dynamic import
+  - Command should be eagerly registered
+  - But their implementations should only be loaded when they are actually called
+- Make sure that files support Buffers and encoding

src/BashEnv.ts

@@ -1,42 +1,6 @@
-import { aliasCommand, unaliasCommand } from "./commands/alias/alias.js";
-import { awkCommand } from "./commands/awk/awk.js";
-import { basenameCommand } from "./commands/basename/basename.js";
-import { bashCommand, shCommand } from "./commands/bash/bash.js";
-import { catCommand } from "./commands/cat/cat.js";
-import { chmodCommand } from "./commands/chmod/chmod.js";
-import { clearCommand } from "./commands/clear/clear.js";
-import { cpCommand } from "./commands/cp/cp.js";
-import { cutCommand } from "./commands/cut/cut.js";
-import { dirnameCommand } from "./commands/dirname/dirname.js";
-import { duCommand } from "./commands/du/du.js";
-// Import commands
-import { echoCommand } from "./commands/echo/echo.js";
-import { envCommand, printenvCommand } from "./commands/env/env.js";
-import { findCommand } from "./commands/find/find.js";
-import { grepCommand } from "./commands/grep/grep.js";
-import { headCommand } from "./commands/head/head.js";
-import { historyCommand } from "./commands/history/history.js";
-import { lnCommand } from "./commands/ln/ln.js";
-import { lsCommand } from "./commands/ls/ls.js";
-import { mkdirCommand } from "./commands/mkdir/mkdir.js";
-import { mvCommand } from "./commands/mv/mv.js";
-import { printfCommand } from "./commands/printf/printf.js";
-import { pwdCommand } from "./commands/pwd/pwd.js";
-import { readlinkCommand } from "./commands/readlink/readlink.js";
-import { rmCommand } from "./commands/rm/rm.js";
-import { sedCommand } from "./commands/sed/sed.js";
-import { sortCommand } from "./commands/sort/sort.js";
-import { statCommand } from "./commands/stat/stat.js";
-import { tailCommand } from "./commands/tail/tail.js";
-import { teeCommand } from "./commands/tee/tee.js";
-import { touchCommand } from "./commands/touch/touch.js";
-import { trCommand } from "./commands/tr/tr.js";
-import { treeCommand } from "./commands/tree/tree.js";
-import { falseCommand, trueCommand } from "./commands/true/true.js";
-import { uniqCommand } from "./commands/uniq/uniq.js";
-import { wcCommand } from "./commands/wc/wc.js";
-import { xargsCommand } from "./commands/xargs/xargs.js";
+import { createLazyCommands } from "./commands/registry.js";
 import { type IFileSystem, VirtualFs } from "./fs.js";
+import type { FileContent } from "./fs-interface.js";
 import {
   GlobExpander,
   type Pipeline,
@@ -60,7 +24,7 @@ export interface BashEnvOptions {
    * Initial files to populate the virtual filesystem.
    * Only used when fs is not provided.
    */
-  files?: Record<string, string>;
+  files?: Record<string, FileContent>;
   /**
    * Environment variables
    */
@@ -90,7 +54,7 @@ export interface BashEnvOptions {
 }
 
 export class BashEnv {
-  private fs: IFileSystem;
+  readonly fs: IFileSystem;
   private cwd: string;
   private env: Record<string, string>;
   private commands: CommandRegistry = new Map();
@@ -150,48 +114,11 @@ export class BashEnv {
       }
     }
 
-    // Register built-in commands
-    this.registerCommand(echoCommand);
-    this.registerCommand(catCommand);
-    this.registerCommand(lsCommand);
-    this.registerCommand(mkdirCommand);
-    this.registerCommand(pwdCommand);
-    this.registerCommand(touchCommand);
-    this.registerCommand(rmCommand);
-    this.registerCommand(cpCommand);
-    this.registerCommand(mvCommand);
-    this.registerCommand(headCommand);
-    this.registerCommand(tailCommand);
-    this.registerCommand(wcCommand);
-    this.registerCommand(grepCommand);
-    this.registerCommand(sortCommand);
-    this.registerCommand(uniqCommand);
-    this.registerCommand(findCommand);
-    this.registerCommand(sedCommand);
-    this.registerCommand(cutCommand);
-    this.registerCommand(trCommand);
-    this.registerCommand(trueCommand);
-    this.registerCommand(falseCommand);
-    this.registerCommand(basenameCommand);
-    this.registerCommand(dirnameCommand);
-    this.registerCommand(teeCommand);
-    this.registerCommand(xargsCommand);
-    this.registerCommand(envCommand);
-    this.registerCommand(printenvCommand);
-    this.registerCommand(treeCommand);
-    this.registerCommand(statCommand);
-    this.registerCommand(duCommand);
-    this.registerCommand(awkCommand);
-    this.registerCommand(chmodCommand);
-    this.registerCommand(clearCommand);
-    this.registerCommand(aliasCommand);
-    this.registerCommand(unaliasCommand);
-    this.registerCommand(historyCommand);
-    this.registerCommand(lnCommand);
-    this.registerCommand(readlinkCommand);
-    this.registerCommand(printfCommand);
-    this.registerCommand(bashCommand);
-    this.registerCommand(shCommand);
+    // Register built-in commands with lazy loading
+    // Commands are registered eagerly but implementations load on first use
+    for (const cmd of createLazyCommands()) {
+      this.registerCommand(cmd);
+    }
   }
 
   registerCommand(command: Command): void {

src/commands/awk/awk.binary.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { BashEnv } from "../../BashEnv.js";
+
+describe("awk with binary content", () => {
+  it("should process binary file with awk", async () => {
+    const env = new BashEnv({
+      files: {
+        "/data.bin": new Uint8Array([
+          0x31,
+          0x20,
+          0x32,
+          0x0a, // 1 2\n
+          0x33,
+          0x20,
+          0x34,
+          0x0a, // 3 4\n
+        ]),
+      },
+    });
+
+    const result = await env.exec("awk '{print $1 + $2}' /data.bin");
+    expect(result.stdout).toBe("3\n7\n");
+    expect(result.exitCode).toBe(0);
+  });
+});

src/commands/awk/awk.ts

@@ -1,8 +1,8 @@
 import type { Command, CommandContext, ExecResult } from "../../types.js";
 import { hasHelpFlag, showHelp, unknownOption } from "../help.js";
-import type { AwkContext } from "./types.js";
-import { parseAwkProgram } from "./parser.js";
 import { executeAwkAction, matchesPattern } from "./executor.js";
+import { parseAwkProgram } from "./parser.js";
+import type { AwkContext } from "./types.js";
 
 const awkHelp = {
   name: "awk",

src/commands/awk/executor.ts

@@ -1,10 +1,6 @@
-import type { AwkContext } from "./types.js";
-import {
-  evaluateExpression,
-  evaluateCondition,
-  evaluateConcatenation,
-} from "./expressions.js";
+import { evaluateCondition, evaluateExpression } from "./expressions.js";
 import { findMatchingBrace } from "./parser.js";
+import type { AwkContext } from "./types.js";
 
 export function executeAwkAction(action: string, ctx: AwkContext): string {
   let output = "";
@@ -511,7 +507,7 @@ function evaluatePrintf(args: string, ctx: AwkContext): string {
         valueIdx++;
         i = j + 1;
       } else if (spec === "d" || spec === "i") {
-        let val = values[valueIdx]
+        const val = values[valueIdx]
           ? Math.floor(Number(evaluateExpression(values[valueIdx], ctx)))
           : 0;
         let valStr = String(val);
@@ -522,7 +518,7 @@ function evaluatePrintf(args: string, ctx: AwkContext): string {
         valueIdx++;
         i = j + 1;
       } else if (spec === "f") {
-        let val = values[valueIdx]
+        const val = values[valueIdx]
           ? Number(evaluateExpression(values[valueIdx], ctx))
           : 0;
         const prec = precision ? parseInt(precision, 10) : 6;

src/commands/awk/expressions.ts

@@ -1,15 +1,15 @@
-import type { AwkContext } from "./types.js";
 import {
-  awkLength,
-  awkSubstr,
+  awkGsub,
   awkIndex,
+  awkLength,
   awkSplit,
+  awkSprintf,
   awkSub,
-  awkGsub,
+  awkSubstr,
   awkTolower,
   awkToupper,
-  awkSprintf,
 } from "./functions.js";
+import type { AwkContext } from "./types.js";
 
 export function evaluateExpression(
   expr: string,
@@ -292,7 +292,9 @@ export function evaluateCondition(condition: string, ctx: AwkContext): boolean {
   if (inMatch) {
     const key = String(evaluateExpression(inMatch[1].trim(), ctx));
     const arrayName = inMatch[2];
-    return !!(ctx.arrays[arrayName] && ctx.arrays[arrayName][key] !== undefined);
+    return !!(
+      ctx.arrays[arrayName] && ctx.arrays[arrayName][key] !== undefined
+    );
   }
 
   // NR comparisons
@@ -308,8 +310,7 @@ export function evaluateCondition(condition: string, ctx: AwkContext): boolean {
   if (fieldRegex) {
     const fieldNum = parseInt(fieldRegex[1], 10);
     const pattern = fieldRegex[2];
-    const fieldVal =
-      fieldNum === 0 ? ctx.line : ctx.fields[fieldNum - 1] || "";
+    const fieldVal = fieldNum === 0 ? ctx.line : ctx.fields[fieldNum - 1] || "";
     return new RegExp(pattern).test(fieldVal);
   }
 
@@ -318,8 +319,7 @@ export function evaluateCondition(condition: string, ctx: AwkContext): boolean {
   if (fieldNotRegex) {
     const fieldNum = parseInt(fieldNotRegex[1], 10);
     const pattern = fieldNotRegex[2];
-    const fieldVal =
-      fieldNum === 0 ? ctx.line : ctx.fields[fieldNum - 1] || "";
+    const fieldVal = fieldNum === 0 ? ctx.line : ctx.fields[fieldNum - 1] || "";
     return !new RegExp(pattern).test(fieldVal);
   }
 

src/commands/awk/functions.ts

@@ -190,9 +190,7 @@ export function awkSprintf(
 
       const spec = format[j];
       if (spec === "s" || spec === "d" || spec === "i" || spec === "f") {
-        const val = values[valueIdx]
-          ? evaluateExpr(values[valueIdx], ctx)
-          : "";
+        const val = values[valueIdx] ? evaluateExpr(values[valueIdx], ctx) : "";
         result += String(val);
         valueIdx++;
         i = j + 1;

src/commands/awk/parser.ts

@@ -75,10 +75,7 @@ export function parseAwkProgram(program: string): ParsedProgram {
           }
         } else {
           // Condition only (no action) or just a print expression
-          if (
-            remaining.startsWith("print") ||
-            remaining.startsWith("printf")
-          ) {
+          if (remaining.startsWith("print") || remaining.startsWith("printf")) {
             result.main.push({ pattern: null, action: remaining });
           } else {
             // It's a condition without action - default to print

src/commands/cat/cat.binary.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { BashEnv } from "../../BashEnv.js";
+
+describe("cat with binary files", () => {
+  it("should output binary content unchanged", async () => {
+    const env = new BashEnv({
+      files: {
+        "/binary.bin": new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]), // "Hello"
+      },
+    });
+
+    const result = await env.exec("cat /binary.bin");
+    expect(result.stdout).toBe("Hello");
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("should handle null bytes in content", async () => {
+    const env = new BashEnv({
+      files: {
+        "/binary.bin": new Uint8Array([0x41, 0x00, 0x42, 0x00, 0x43]), // A\0B\0C
+      },
+    });
+
+    const result = await env.exec("cat /binary.bin");
+    expect(result.stdout).toBe("A\0B\0C");
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("should concatenate multiple binary files", async () => {
+    const env = new BashEnv({
+      files: {
+        "/a.bin": new Uint8Array([0x41, 0x42]), // "AB"
+        "/b.bin": new Uint8Array([0x43, 0x44]), // "CD"
+      },
+    });
+
+    const result = await env.exec("cat /a.bin /b.bin");
+    expect(result.stdout).toBe("ABCD");
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("should number lines in binary file with -n", async () => {
+    const env = new BashEnv({
+      files: {
+        "/binary.bin": new Uint8Array([0x41, 0x0a, 0x42, 0x0a]), // "A\nB\n"
+      },
+    });
+
+    const result = await env.exec("cat -n /binary.bin");
+    expect(result.stdout).toBe("     1\tA\n     2\tB\n");
+    expect(result.exitCode).toBe(0);
+  });
+});

src/commands/cp/cp.binary.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { BashEnv } from "../../BashEnv.js";
+
+describe("cp with binary files", () => {
+  it("should copy binary file preserving content", async () => {
+    const data = new Uint8Array([0x00, 0xff, 0x00, 0xff, 0x7f]);
+    const env = new BashEnv({
+      files: { "/src.bin": data },
+    });
+
+    await env.exec("cp /src.bin /dst.bin");
+
+    // Check the copied file's raw bytes via the fs directly
+    // (cat returns string which can't faithfully represent 0xff bytes)
+    const copiedContent = await env.fs.readFileBuffer("/dst.bin");
+    expect(copiedContent.length).toBe(5);
+    expect(copiedContent[0]).toBe(0x00);
+    expect(copiedContent[1]).toBe(0xff);
+    expect(copiedContent[2]).toBe(0x00);
+    expect(copiedContent[3]).toBe(0xff);
+    expect(copiedContent[4]).toBe(0x7f);
+  });
+});