Unskip 31 (#24)

* Unskip many tests

* Unskip more

* fs

* skip

* LINENO

Author: cramforce

src/Bash.ts

@@ -20,6 +20,7 @@ import {
   isLazyCommand,
 } from "./custom-commands.js";
 import { InMemoryFs } from "./fs/in-memory-fs/in-memory-fs.js";
+import { initFilesystem } from "./fs/init.js";
 import type { IFileSystem, InitialFiles } from "./fs/interface.js";
 import {
   ArithmeticError,
@@ -205,6 +206,9 @@ export class Bash {
       commandCount: 0,
       lastExitCode: 0,
       lastArg: "", // $_ is initially empty (or could be shell name)
+      startTime: Date.now(),
+      lastBackgroundPid: 0,
+      currentLine: 1, // $LINENO starts at 1
       options: {
         errexit: false,
         pipefail: false,
@@ -216,21 +220,9 @@ export class Bash {
       loopDepth: 0,
     };
 
-    // Create essential directories for InMemoryFs
-    if (fs instanceof InMemoryFs) {
-      try {
-        // Always create /bin for PATH-based command resolution
-        fs.mkdirSync("/bin", { recursive: true });
-        fs.mkdirSync("/usr/bin", { recursive: true });
-        // Create additional directories only for default layout
-        if (this.useDefaultLayout) {
-          fs.mkdirSync("/home/user", { recursive: true });
-          fs.mkdirSync("/tmp", { recursive: true });
-        }
-      } catch {
-        // Ignore errors - directories may already exist
-      }
-    }
+    // Initialize filesystem with standard directories and device files
+    // Only applies to InMemoryFs - other filesystems use real directories
+    initFilesystem(fs, this.useDefaultLayout);
 
     if (cwd !== "/" && fs instanceof InMemoryFs) {
       try {
@@ -265,10 +257,14 @@ export class Bash {
 
   registerCommand(command: Command): void {
     this.commands.set(command.name, command);
-    // Always create command stubs in /bin for PATH-based resolution
-    if (this.fs instanceof InMemoryFs) {
+    // Create command stubs in /bin for PATH-based resolution
+    // Works for both InMemoryFs and OverlayFs (both have writeFileSync)
+    const fs = this.fs as {
+      writeFileSync?: (path: string, content: string) => void;
+    };
+    if (typeof fs.writeFileSync === "function") {
       try {
-        this.fs.writeFileSync(
+        fs.writeFileSync(
           `/bin/${command.name}`,
           `#!/bin/bash\n# Built-in command: ${command.name}\n`,
         );

src/ast/types.ts

@@ -18,6 +18,8 @@
 /** Base interface for all AST nodes */
 export interface ASTNode {
   type: string;
+  /** Source line number (1-based) for $LINENO tracking. May be 0 or undefined for synthesized nodes. */
+  line?: number;
 }
 
 /** Position information for error reporting */

src/commands/ls/ls.test.ts

@@ -21,8 +21,8 @@ describe("ls", () => {
       cwd: "/",
     });
     const result = await env.exec("ls");
-    // /bin and /usr always exist for PATH-based command resolution
-    expect(result.stdout).toBe("bin\nfile.txt\nusr\n");
+    // /bin, /usr, /dev, /proc always exist for PATH-based command resolution and system compatibility
+    expect(result.stdout).toBe("bin\ndev\nfile.txt\nproc\nusr\n");
     expect(result.stderr).toBe("");
   });
 

src/commands/mkdir/mkdir.test.ts

@@ -9,16 +9,16 @@ describe("mkdir", () => {
     expect(result.stderr).toBe("");
     expect(result.exitCode).toBe(0);
     const ls = await env.exec("ls /");
-    // /bin and /usr always exist for PATH-based command resolution
-    expect(ls.stdout).toBe("bin\nnewdir\nusr\n");
+    // /bin, /usr, /dev, /proc always exist
+    expect(ls.stdout).toBe("bin\ndev\nnewdir\nproc\nusr\n");
   });
 
   it("should create multiple directories", async () => {
     const env = new Bash({ cwd: "/" });
     await env.exec("mkdir /dir1 /dir2 /dir3");
     const ls = await env.exec("ls /");
-    // /bin and /usr always exist for PATH-based command resolution
-    expect(ls.stdout).toBe("bin\ndir1\ndir2\ndir3\nusr\n");
+    // /bin, /usr, /dev, /proc always exist
+    expect(ls.stdout).toBe("bin\ndev\ndir1\ndir2\ndir3\nproc\nusr\n");
   });
 
   it("should create nested directories with -p", async () => {

src/commands/rm/rm.test.ts

@@ -24,8 +24,8 @@ describe("rm", () => {
     });
     await env.exec("rm /a.txt /b.txt /c.txt");
     const ls = await env.exec("ls /");
-    // /bin and /usr always exist for PATH-based command resolution
-    expect(ls.stdout).toBe("bin\nusr\n");
+    // /bin, /usr, /dev, /proc always exist
+    expect(ls.stdout).toBe("bin\ndev\nproc\nusr\n");
   });
 
   it("should error on missing file", async () => {

src/fs/init.ts

@@ -0,0 +1,96 @@
+/**
+ * Filesystem Initialization
+ *
+ * Sets up the default filesystem structure for the bash environment
+ * including /dev, /proc, and common directories.
+ */
+
+import { formatProcStatus, KERNEL_VERSION } from "../shell-metadata.js";
+import type { IFileSystem } from "./interface.js";
+
+/**
+ * Interface for filesystems that support sync initialization
+ * (both InMemoryFs and OverlayFs implement these)
+ */
+interface SyncInitFs {
+  mkdirSync(path: string, options?: { recursive?: boolean }): void;
+  writeFileSync(path: string, content: string | Uint8Array): void;
+}
+
+/**
+ * Check if filesystem supports sync initialization
+ */
+function isSyncInitFs(fs: IFileSystem): fs is IFileSystem & SyncInitFs {
+  const maybeFs = fs as unknown as Partial<SyncInitFs>;
+  return (
+    typeof maybeFs.mkdirSync === "function" &&
+    typeof maybeFs.writeFileSync === "function"
+  );
+}
+
+/**
+ * Initialize common directories like /home/user and /tmp
+ */
+function initCommonDirectories(
+  fs: SyncInitFs,
+  useDefaultLayout: boolean,
+): void {
+  // Always create /bin for PATH-based command resolution
+  fs.mkdirSync("/bin", { recursive: true });
+  fs.mkdirSync("/usr/bin", { recursive: true });
+
+  // Create additional directories only for default layout
+  if (useDefaultLayout) {
+    fs.mkdirSync("/home/user", { recursive: true });
+    fs.mkdirSync("/tmp", { recursive: true });
+  }
+}
+
+/**
+ * Initialize /dev with common device files
+ */
+function initDevFiles(fs: SyncInitFs): void {
+  fs.mkdirSync("/dev", { recursive: true });
+  fs.writeFileSync("/dev/null", "");
+  fs.writeFileSync("/dev/zero", new Uint8Array(0));
+  fs.writeFileSync("/dev/stdin", "");
+  fs.writeFileSync("/dev/stdout", "");
+  fs.writeFileSync("/dev/stderr", "");
+}
+
+/**
+ * Initialize /proc with simulated process information
+ */
+function initProcFiles(fs: SyncInitFs): void {
+  fs.mkdirSync("/proc/self/fd", { recursive: true });
+
+  // Kernel version (from shared metadata)
+  fs.writeFileSync("/proc/version", `${KERNEL_VERSION}\n`);
+
+  // Process info (from shared metadata)
+  fs.writeFileSync("/proc/self/exe", "/bin/bash");
+  fs.writeFileSync("/proc/self/cmdline", "bash\0");
+  fs.writeFileSync("/proc/self/comm", "bash\n");
+  fs.writeFileSync("/proc/self/status", formatProcStatus());
+
+  // File descriptors
+  fs.writeFileSync("/proc/self/fd/0", "/dev/stdin");
+  fs.writeFileSync("/proc/self/fd/1", "/dev/stdout");
+  fs.writeFileSync("/proc/self/fd/2", "/dev/stderr");
+}
+
+/**
+ * Initialize the filesystem with standard directories and files
+ * Works with both InMemoryFs and OverlayFs (both write to memory)
+ */
+export function initFilesystem(
+  fs: IFileSystem,
+  useDefaultLayout: boolean,
+): void {
+  // Initialize for filesystems that support sync methods (InMemoryFs and OverlayFs)
+  if (isSyncInitFs(fs)) {
+    initCommonDirectories(fs, useDefaultLayout);
+    initDevFiles(fs);
+    initProcFiles(fs);
+  }
+}

src/fs/overlay-fs/overlay-fs.ts

@@ -145,6 +145,52 @@ export class OverlayFs implements IFileSystem {
     return this.mountPoint;
   }
 
+  /**
+   * Create a virtual directory in memory (sync, for initialization)
+   */
+  mkdirSync(path: string, _options?: MkdirOptions): void {
+    const normalized = this.normalizePath(path);
+    const parts = normalized.split("/").filter(Boolean);
+    let current = "";
+    for (const part of parts) {
+      current += `/${part}`;
+      if (!this.memory.has(current)) {
+        this.memory.set(current, {
+          type: "directory",
+          mode: 0o755,
+          mtime: new Date(),
+        });
+      }
+    }
+  }
+
+  /**
+   * Create a virtual file in memory (sync, for initialization)
+   */
+  writeFileSync(path: string, content: string | Uint8Array): void {
+    const normalized = this.normalizePath(path);
+    // Ensure parent directories exist
+    const parent = this.getDirname(normalized);
+    if (parent !== "/") {
+      this.mkdirSync(parent);
+    }
+    const buffer =
+      content instanceof Uint8Array
+        ? content
+        : new TextEncoder().encode(content);
+    this.memory.set(normalized, {
+      type: "file",
+      content: buffer,
+      mode: 0o644,
+      mtime: new Date(),
+    });
+  }
+
+  private getDirname(path: string): string {
+    const lastSlash = path.lastIndexOf("/");
+    return lastSlash === 0 ? "/" : path.slice(0, lastSlash);
+  }
+
   /**
    * Normalize a virtual path (resolve . and .., ensure starts with /)
    */

src/interpreter/expansion.ts

@@ -635,33 +635,104 @@ export async function expandWordWithGlob(
     }
   }
 
-  // Handle unquoted $@ and $* specially - they should expand to individual args
-  // without IFS-based word splitting
-  if (!hasQuoted && hasArrayVar) {
-    // Check if this is purely $@ or $* (not part of a larger word)
-    if (wordParts.length === 1 && wordParts[0].type === "ParameterExpansion") {
-      const param = wordParts[0].parameter;
-      if (param === "@" || param === "*") {
-        // Get individual positional parameters
-        const numParams = Number.parseInt(ctx.state.env["#"] || "0", 10);
-        if (numParams === 0) {
-          return { values: [], quoted: false };
-        }
-        const params: string[] = [];
-        for (let i = 1; i <= numParams; i++) {
-          params.push(ctx.state.env[String(i)] || "");
+  // Handle "$@" and "$*" with adjacent text inside double quotes, e.g., "-$@-"
+  // "$@": Each positional parameter becomes a separate word, with prefix joined to first
+  //       and suffix joined to last. If no params, produces nothing (or just prefix+suffix if present)
+  // "$*": All params joined with IFS as ONE word. If no params, produces one empty word.
+  if (wordParts.length === 1 && wordParts[0].type === "DoubleQuoted") {
+    const dqPart = wordParts[0];
+    // Find if there's a $@ or $* inside
+    let atIndex = -1;
+    let isStar = false;
+    for (let i = 0; i < dqPart.parts.length; i++) {
+      const p = dqPart.parts[i];
+      if (
+        p.type === "ParameterExpansion" &&
+        (p.parameter === "@" || p.parameter === "*")
+      ) {
+        atIndex = i;
+        isStar = p.parameter === "*";
+        break;
+      }
+    }
+
+    if (atIndex !== -1) {
+      // Check if this is a simple $@ or $* without operations like ${*-default}
+      const paramPart = dqPart.parts[atIndex];
+      if (paramPart.type === "ParameterExpansion" && paramPart.operation) {
+        // Has an operation - let normal expansion handle it
+        atIndex = -1;
+      }
+    }
+
+    if (atIndex !== -1) {
+      // Get positional parameters
+      const numParams = Number.parseInt(ctx.state.env["#"] || "0", 10);
+
+      // Expand prefix (parts before $@/$*)
+      let prefix = "";
+      for (let i = 0; i < atIndex; i++) {
+        prefix += await expandPart(ctx, dqPart.parts[i]);
+      }
+
+      // Expand suffix (parts after $@/$*)
+      let suffix = "";
+      for (let i = atIndex + 1; i < dqPart.parts.length; i++) {
+        suffix += await expandPart(ctx, dqPart.parts[i]);
+      }
+
+      if (numParams === 0) {
+        if (isStar) {
+          // "$*" with no params -> one empty word (prefix + suffix)
+          return { values: [prefix + suffix], quoted: true };
         }
-        return { values: params, quoted: false };
+        // "$@" with no params -> no words (unless there's prefix/suffix)
+        const combined = prefix + suffix;
+        return { values: combined ? [combined] : [], quoted: true };
+      }
+
+      // Get individual positional parameters
+      const params: string[] = [];
+      for (let i = 1; i <= numParams; i++) {
+        params.push(ctx.state.env[String(i)] || "");
       }
+
+      if (isStar) {
+        // "$*" - join all params with IFS into one word
+        const ifsSep = getIfsSeparator(ctx.state.env);
+        return {
+          values: [prefix + params.join(ifsSep) + suffix],
+          quoted: true,
+        };
+      }
+
+      // "$@" - each param is a separate word
+      // Join prefix with first, suffix with last
+      if (params.length === 1) {
+        return { values: [prefix + params[0] + suffix], quoted: true };
+      }
+
+      const result = [
+        prefix + params[0],
+        ...params.slice(1, -1),
+        params[params.length - 1] + suffix,
+      ];
+      return { values: result, quoted: true };
     }
   }
 
+  // Note: Unquoted $@ and $* are handled by normal expansion + word splitting.
+  // They expand to positional parameters joined by space, then split on IFS.
+  // The special handling above is only for quoted "$@" and "$*" inside double quotes.
+
   // No brace expansion or single value - use original logic
   // Word splitting based on IFS
   // If IFS is set to empty string, no word splitting occurs
   // Word splitting applies to results of parameter expansion, command substitution, and arithmetic expansion
+  // Note: hasQuoted being true does NOT prevent word splitting - unquoted expansions like $a in $a"$b"
+  // should still be split. The smartWordSplit function handles this by treating quoted parts as
+  // non-splittable segments that join with adjacent fields.
   if (
-    !hasQuoted &&
     (hasCommandSub || hasArrayVar || hasParamExpansion) &&
     !isIfsEmpty(ctx.state.env)
   ) {