@scelar/nodepod 1.0.0

package/src/shell/shell-parser.ts

@@ -0,0 +1,429 @@
+// Tokenizer + recursive-descent parser.
+// Converts a shell command string into an AST (ListNode).
+
+import type {
+  Token,
+  TokenType,
+  ListNode,
+  ListEntry,
+  ListOperator,
+  PipelineNode,
+  CommandNode,
+  RedirectNode,
+} from "./shell-types";
+import type { MemoryVolume } from "../memory-volume";
+
+/* ------------------------------------------------------------------ */
+/*  Variable & substitution expansion                                  */
+/* ------------------------------------------------------------------ */
+
+// Expand $VAR, ${VAR}, $?, $$, $0, and tilde.
+// Single-quote handling is the caller's job.
+export function expandVariables(
+  raw: string,
+  env: Record<string, string>,
+  lastExit: number,
+): string {
+  let result = "";
+  let i = 0;
+
+  if (raw === "~" || raw.startsWith("~/")) {
+    const home = env.HOME || "/home/user";
+    return home + raw.slice(1);
+  }
+
+  while (i < raw.length) {
+    if (raw[i] === "\\") {
+      i++;
+      if (i < raw.length) result += raw[i++];
+      continue;
+    }
+
+    if (raw[i] === "$") {
+      i++;
+      if (i >= raw.length) {
+        result += "$";
+        break;
+      }
+
+      if (raw[i] === "?") {
+        result += String(lastExit);
+        i++;
+        continue;
+      }
+      if (raw[i] === "$") {
+        result += "1"; // stub PID
+        i++;
+        continue;
+      }
+      if (raw[i] === "0") {
+        result += "nodepod";
+        i++;
+        continue;
+      }
+      if (raw[i] === "#") {
+        result += "0"; // $# stub
+        i++;
+        continue;
+      }
+
+      if (raw[i] === "{") {
+        i++;
+        let name = "";
+        while (i < raw.length && raw[i] !== "}" && raw[i] !== ":" && raw[i] !== "-" && raw[i] !== "=") {
+          name += raw[i++];
+        }
+        let defaultVal = "";
+        let useDefault = false;
+        if (i < raw.length && (raw[i] === ":" || raw[i] === "-")) {
+          useDefault = true;
+          if (raw[i] === ":") i++;
+          if (i < raw.length && (raw[i] === "-" || raw[i] === "=")) i++;
+          while (i < raw.length && raw[i] !== "}") {
+            defaultVal += raw[i++];
+          }
+        }
+        if (i < raw.length && raw[i] === "}") i++;
+
+        const val = env[name];
+        if (val !== undefined && val !== "") {
+          result += val;
+        } else if (useDefault) {
+          result += defaultVal;
+        }
+        continue;
+      }
+
+      let name = "";
+      while (i < raw.length && /[a-zA-Z0-9_]/.test(raw[i])) {
+        name += raw[i++];
+      }
+      if (name) {
+        result += env[name] ?? "";
+      } else {
+        result += "$";
+      }
+      continue;
+    }
+
+    result += raw[i++];
+  }
+
+  return result;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Glob expansion                                                     */
+/* ------------------------------------------------------------------ */
+
+export function expandGlob(
+  pattern: string,
+  cwd: string,
+  volume: MemoryVolume,
+): string[] {
+  if (!pattern.includes("*") && !pattern.includes("?")) return [pattern];
+
+  const lastSlash = pattern.lastIndexOf("/");
+  let dir: string;
+  let filePattern: string;
+
+  if (lastSlash === -1) {
+    dir = cwd;
+    filePattern = pattern;
+  } else {
+    dir = pattern.slice(0, lastSlash) || "/";
+    if (!dir.startsWith("/")) dir = `${cwd}/${dir}`.replace(/\/+/g, "/");
+    filePattern = pattern.slice(lastSlash + 1);
+  }
+
+  try {
+    const entries = volume.readdirSync(dir);
+    const regex = globToRegex(filePattern);
+    const matches = entries.filter((e) => regex.test(e));
+
+    if (matches.length === 0) return [pattern];
+
+    return matches.sort().map((m) =>
+      lastSlash === -1 ? m : `${dir}/${m}`.replace(/\/+/g, "/"),
+    );
+  } catch {
+    return [pattern];
+  }
+}
+
+function globToRegex(pattern: string): RegExp {
+  let regex = "^";
+  for (const ch of pattern) {
+    if (ch === "*") regex += ".*";
+    else if (ch === "?") regex += ".";
+    else if (".+^${}()|[]\\".includes(ch)) regex += "\\" + ch;
+    else regex += ch;
+  }
+  regex += "$";
+  return new RegExp(regex);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Tokenizer                                                          */
+/* ------------------------------------------------------------------ */
+
+export function tokenize(
+  input: string,
+  env: Record<string, string>,
+  lastExit: number,
+): Token[] {
+  const tokens: Token[] = [];
+  let i = 0;
+
+  while (i < input.length) {
+    if (input[i] === " " || input[i] === "\t") {
+      i++;
+      continue;
+    }
+
+    if (input[i] === "\n") {
+      tokens.push({ type: "newline", value: "\n" });
+      i++;
+      continue;
+    }
+
+    if (input[i] === "#") {
+      while (i < input.length && input[i] !== "\n") i++;
+      continue;
+    }
+
+    if (input.slice(i, i + 4) === "2>&1") {
+      tokens.push({ type: "redirect-2to1", value: "2>&1" });
+      i += 4;
+      continue;
+    }
+
+    if (input[i] === ">" && input[i + 1] === ">") {
+      tokens.push({ type: "redirect-app", value: ">>" });
+      i += 2;
+      continue;
+    }
+
+    if (input[i] === ">") {
+      tokens.push({ type: "redirect-out", value: ">" });
+      i++;
+      continue;
+    }
+
+    if (input[i] === "<") {
+      tokens.push({ type: "redirect-in", value: "<" });
+      i++;
+      continue;
+    }
+
+    if (input[i] === "&" && input[i + 1] === "&") {
+      tokens.push({ type: "and", value: "&&" });
+      i += 2;
+      continue;
+    }
+
+    if (input[i] === "|" && input[i + 1] === "|") {
+      tokens.push({ type: "or", value: "||" });
+      i += 2;
+      continue;
+    }
+
+    if (input[i] === "|") {
+      tokens.push({ type: "pipe", value: "|" });
+      i++;
+      continue;
+    }
+
+    if (input[i] === ";") {
+      tokens.push({ type: "semi", value: ";" });
+      i++;
+      continue;
+    }
+
+    let word = "";
+    while (i < input.length) {
+      const ch = input[i];
+
+      if (ch === " " || ch === "\t" || ch === "\n") break;
+      if (ch === "|" || ch === "&" || ch === ";" || ch === ">" || ch === "<") break;
+      if (ch === "2" && input.slice(i, i + 4) === "2>&1") break;
+
+      if (ch === "\\") {
+        i++;
+        if (i < input.length) word += input[i++];
+        continue;
+      }
+
+      // single quotes: no expansion
+      if (ch === "'") {
+        i++;
+        while (i < input.length && input[i] !== "'") {
+          word += input[i++];
+        }
+        if (i < input.length) i++;
+        continue;
+      }
+
+      // double quotes: expand variables
+      if (ch === '"') {
+        i++;
+        let dqContent = "";
+        while (i < input.length && input[i] !== '"') {
+          if (input[i] === "\\" && i + 1 < input.length) {
+            const next = input[i + 1];
+            if (next === '"' || next === "\\" || next === "$" || next === "`") {
+              dqContent += next;
+              i += 2;
+              continue;
+            }
+          }
+          dqContent += input[i++];
+        }
+        if (i < input.length) i++;
+        word += expandVariables(dqContent, env, lastExit);
+        continue;
+      }
+
+      word += ch;
+      i++;
+    }
+
+    if (word.length > 0) {
+      const expanded = expandVariables(word, env, lastExit);
+      tokens.push({ type: "word", value: expanded });
+    }
+  }
+
+  tokens.push({ type: "eof", value: "" });
+  return tokens;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Recursive-descent parser                                           */
+/* ------------------------------------------------------------------ */
+
+class Parser {
+  private tokens: Token[];
+  private pos = 0;
+
+  constructor(tokens: Token[]) {
+    this.tokens = tokens;
+  }
+
+  private peek(): Token {
+    return this.tokens[this.pos] ?? { type: "eof", value: "" };
+  }
+
+  private advance(): Token {
+    return this.tokens[this.pos++] ?? { type: "eof", value: "" };
+  }
+
+  private skipNewlines(): void {
+    while (this.peek().type === "newline") this.advance();
+  }
+
+  parseList(): ListNode {
+    this.skipNewlines();
+    const entries: ListEntry[] = [];
+
+    while (this.peek().type !== "eof") {
+      this.skipNewlines();
+      if (this.peek().type === "eof") break;
+
+      const pipeline = this.parsePipeline();
+      const op = this.peek();
+
+      if (op.type === "and" || op.type === "or" || op.type === "semi") {
+        this.advance();
+        const operator: ListOperator =
+          op.type === "and" ? "&&" : op.type === "or" ? "||" : ";";
+        entries.push({ pipeline, next: operator });
+      } else {
+        entries.push({ pipeline });
+        break;
+      }
+    }
+
+    return { kind: "list", entries };
+  }
+
+  private parsePipeline(): PipelineNode {
+    const commands: CommandNode[] = [];
+    commands.push(this.parseCommand());
+
+    while (this.peek().type === "pipe") {
+      this.advance();
+      commands.push(this.parseCommand());
+    }
+
+    return { kind: "pipeline", commands };
+  }
+
+  private parseCommand(): CommandNode {
+    const args: string[] = [];
+    const redirects: RedirectNode[] = [];
+    const assignments: Record<string, string> = {};
+
+    // leading KEY=value assignments (only before any regular args)
+    while (this.peek().type === "word") {
+      const val = this.peek().value;
+      const eqIdx = val.indexOf("=");
+      if (eqIdx > 0 && args.length === 0 && /^[a-zA-Z_]/.test(val)) {
+        this.advance();
+        assignments[val.slice(0, eqIdx)] = val.slice(eqIdx + 1);
+      } else {
+        break;
+      }
+    }
+
+    while (true) {
+      const tok = this.peek();
+
+      if (tok.type === "word") {
+        this.advance();
+        args.push(tok.value);
+        continue;
+      }
+
+      if (tok.type === "redirect-out" || tok.type === "redirect-app" || tok.type === "redirect-in") {
+        this.advance();
+        const target = this.peek();
+        if (target.type === "word") {
+          this.advance();
+          const rtype =
+            tok.type === "redirect-out" ? "write" as const :
+            tok.type === "redirect-app" ? "append" as const :
+            "read" as const;
+          redirects.push({ type: rtype, target: target.value });
+        }
+        continue;
+      }
+
+      if (tok.type === "redirect-2to1") {
+        this.advance();
+        redirects.push({ type: "stderr-to-stdout", target: "" });
+        continue;
+      }
+
+      break;
+    }
+
+    return { kind: "command", args, redirects, assignments };
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Public API                                                         */
+/* ------------------------------------------------------------------ */
+
+// Glob expansion happens in the interpreter (needs volume access),
+// but variable expansion and quoting are done here at tokenize time.
+export function parse(
+  input: string,
+  env: Record<string, string>,
+  lastExit: number = 0,
+): ListNode {
+  const tokens = tokenize(input, env, lastExit);
+  const parser = new Parser(tokens);
+  return parser.parseList();
+}

package/src/shell/shell-types.ts

@@ -0,0 +1,85 @@
+import type { MemoryVolume } from "../memory-volume";
+
+/* ------------------------------------------------------------------ */
+/*  Result & context                                                   */
+/* ------------------------------------------------------------------ */
+
+export interface ShellResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface ShellContext {
+  cwd: string;
+  env: Record<string, string>;
+  volume: MemoryVolume;
+  // run a sub-command through the shell (used by npm run, etc.)
+  exec: (cmd: string, opts?: { cwd?: string; env?: Record<string, string> }) => Promise<ShellResult>;
+}
+
+export interface ShellCommand {
+  name: string;
+  execute(args: string[], ctx: ShellContext): Promise<ShellResult>;
+}
+
+/* ------------------------------------------------------------------ */
+/*  AST nodes                                                          */
+/* ------------------------------------------------------------------ */
+
+export interface RedirectNode {
+  type: "write" | "append" | "read" | "stderr-to-stdout";
+  target: string; // file path (empty for 2>&1)
+}
+
+export interface CommandNode {
+  kind: "command";
+  args: string[];
+  redirects: RedirectNode[];
+  assignments: Record<string, string>; // KEY=value before the command
+}
+
+export interface PipelineNode {
+  kind: "pipeline";
+  commands: CommandNode[];
+}
+
+export type ListOperator = "&&" | "||" | ";";
+
+export interface ListEntry {
+  pipeline: PipelineNode;
+  next?: ListOperator; // operator after this pipeline (undefined for last)
+}
+
+export interface ListNode {
+  kind: "list";
+  entries: ListEntry[];
+}
+
+/* ------------------------------------------------------------------ */
+/*  Token types                                                        */
+/* ------------------------------------------------------------------ */
+
+export type TokenType =
+  | "word"
+  | "pipe"          // |
+  | "and"           // &&
+  | "or"            // ||
+  | "semi"          // ;
+  | "redirect-out"  // >
+  | "redirect-app"  // >>
+  | "redirect-in"   // <
+  | "redirect-2to1" // 2>&1
+  | "newline"
+  | "eof";
+
+export interface Token {
+  type: TokenType;
+  value: string;
+}
+
+export type BuiltinFn = (
+  args: string[],
+  ctx: ShellContext,
+  stdin?: string,
+) => Promise<ShellResult> | ShellResult;