shell-dsl 0.0.39 → 0.0.41

package/dist/cjs/src/interpreter/interpreter.cjs

@@ -40,13 +40,17 @@ var __export = (target, all) => {
 var exports_interpreter = {};
 __export(exports_interpreter, {
   Interpreter: () => Interpreter,
+  ExitException: () => ExitException,
   ContinueException: () => ContinueException,
   BreakException: () => BreakException
 });
 module.exports = __toCommonJS(exports_interpreter);
 var import_context = require("./context.cjs");
+var import_lexer = require("../lexer/lexer.cjs");
+var import_parser = require("../parser/parser.cjs");
 var import_stdin = require("../io/stdin.cjs");
 var import_stdout = require("../io/stdout.cjs");
+var import_async_queue = require("../io/async-queue.cjs");
 var import_special_files = require("../fs/special-files.cjs");
 var DEFAULT_IFS = ` 	
 `;
@@ -68,6 +72,14 @@ class ContinueException extends Error {
   }
 }
 
+class ExitException extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super("exit");
+    this.exitCode = exitCode;
+  }
+}
+
 class Interpreter {
   fs;
   cwd;
@@ -76,54 +88,154 @@ class Interpreter {
   redirectObjects;
   loopDepth = 0;
   isTTY;
+  terminal;
+  activeSignal;
+  externalCommand;
+  argv0;
+  positionalParameters;
+  lastExitCode;
   constructor(options) {
     this.fs = options.fs;
     this.cwd = options.cwd;
     this.env = { ...options.env };
     this.commands = options.commands;
     this.redirectObjects = options.redirectObjects ?? {};
-    this.isTTY = options.isTTY ?? false;
+    this.terminal = options.terminal ?? { isTTY: options.isTTY ?? false };
+    this.isTTY = this.terminal.isTTY;
+    this.activeSignal = options.signal ?? new AbortController().signal;
+    this.externalCommand = options.externalCommand;
+    this.argv0 = options.argv0 ?? "sh";
+    this.positionalParameters = [...options.positionalParameters ?? []];
+    this.lastExitCode = options.lastExitCode ?? 0;
   }
   getLoopDepth() {
     return this.loopDepth;
   }
   async execute(ast) {
-    const stdout = import_stdout.createStdout(this.isTTY);
-    const stderr = import_stdout.createStderr(this.isTTY);
-    const exitCode = await this.executeNode(ast, null, stdout, stderr);
-    stdout.close();
-    stderr.close();
+    return this.executeStreaming(ast).exit;
+  }
+  executeStreaming(ast, options = {}) {
+    const terminal = options.terminal ?? this.terminal;
+    const controller = new AbortController;
+    const eventQueue = new import_async_queue.AsyncQueue;
+    if (options.signal) {
+      if (options.signal.aborted) {
+        controller.abort(options.signal.reason);
+      } else {
+        options.signal.addEventListener("abort", () => controller.abort(options.signal?.reason), { once: true });
+      }
+    }
+    const stdout = import_stdout.createStdout(terminal.isTTY, async (chunk) => {
+      eventQueue.push({ fd: 1, chunk });
+      await options.stdout?.write(chunk);
+    });
+    const stderr = import_stdout.createStderr(terminal.isTTY, async (chunk) => {
+      eventQueue.push({ fd: 2, chunk });
+      await options.stderr?.write(chunk);
+    });
+    const previousSignal = this.activeSignal;
+    const previousTerminal = this.terminal;
+    const previousIsTTY = this.isTTY;
+    const stdinSource = this.normalizeInputSource(options.stdin);
+    const exit = (async () => {
+      this.activeSignal = controller.signal;
+      this.terminal = terminal;
+      this.isTTY = terminal.isTTY;
+      let exitCode;
+      try {
+        this.throwIfAborted();
+        exitCode = await this.executeNode(ast, stdinSource, stdout, stderr);
+      } catch (err) {
+        if (err instanceof ExitException) {
+          exitCode = err.exitCode;
+        } else if (controller.signal.aborted) {
+          exitCode = 130;
+        } else {
+          throw err;
+        }
+      } finally {
+        stdout.close();
+        stderr.close();
+        eventQueue.close();
+        this.activeSignal = previousSignal;
+        this.terminal = previousTerminal;
+        this.isTTY = previousIsTTY;
+      }
+      this.lastExitCode = exitCode;
+      return {
+        stdout: await stdout.collect(),
+        stderr: await stderr.collect(),
+        exitCode
+      };
+    })();
     return {
-      stdout: await stdout.collect(),
-      stderr: await stderr.collect(),
-      exitCode
+      stdout: stdout.getReadableStream(),
+      stderr: stderr.getReadableStream(),
+      output: eventQueue,
+      exit,
+      kill: (reason) => controller.abort(reason ?? new Error("Shell execution killed"))
     };
   }
+  normalizeInputSource(source) {
+    if (source === undefined || source === null) {
+      return null;
+    }
+    if (typeof source === "string") {
+      return async function* () {
+        yield new TextEncoder().encode(source);
+      }();
+    }
+    if (Buffer.isBuffer(source)) {
+      return async function* () {
+        yield new Uint8Array(source);
+      }();
+    }
+    return source;
+  }
   async executeNode(node, stdinSource, stdout, stderr) {
+    this.throwIfAborted();
+    let exitCode;
     switch (node.type) {
       case "command":
-        return this.executeCommand(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeCommand(node, stdinSource, stdout, stderr);
+        break;
       case "pipeline":
-        return this.executePipeline(node.commands, stdinSource, stdout, stderr);
+        exitCode = await this.executePipeline(node.commands, stdinSource, stdout, stderr);
+        break;
       case "sequence":
-        return this.executeSequence(node.commands, stdinSource, stdout, stderr);
+        exitCode = await this.executeSequence(node.commands, stdinSource, stdout, stderr);
+        break;
       case "and":
-        return this.executeAnd(node.left, node.right, stdinSource, stdout, stderr);
+        exitCode = await this.executeAnd(node.left, node.right, stdinSource, stdout, stderr);
+        break;
       case "or":
-        return this.executeOr(node.left, node.right, stdinSource, stdout, stderr);
+        exitCode = await this.executeOr(node.left, node.right, stdinSource, stdout, stderr);
+        break;
       case "if":
-        return this.executeIf(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeIf(node, stdinSource, stdout, stderr);
+        break;
       case "for":
-        return this.executeFor(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeFor(node, stdinSource, stdout, stderr);
+        break;
       case "while":
-        return this.executeWhile(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeWhile(node, stdinSource, stdout, stderr);
+        break;
       case "until":
-        return this.executeUntil(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeUntil(node, stdinSource, stdout, stderr);
+        break;
       case "case":
-        return this.executeCase(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeCase(node, stdinSource, stdout, stderr);
+        break;
       default:
         throw new Error("Cannot execute unknown node type");
     }
+    this.lastExitCode = exitCode;
+    return exitCode;
+  }
+  throwIfAborted() {
+    if (this.activeSignal.aborted) {
+      throw this.activeSignal.reason ?? new Error("Shell execution aborted");
+    }
   }
   async executeCommand(node, stdinSource, stdout, stderr) {
     const assignmentEnv = { ...this.env };
@@ -171,95 +283,288 @@ class Interpreter {
     if (stdoutToStderr) {
       actualStdout = actualStderr;
     }
+    let exitCode = await this.invokeCommand(name, args, actualStdin, actualStdout, actualStderr, assignmentEnv);
+    if (actualStdout !== stdout) {
+      actualStdout.close();
+    }
+    if (actualStderr !== stderr && actualStderr !== actualStdout) {
+      actualStderr.close();
+    }
+    try {
+      await Promise.all(fileWritePromises);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const writeRedirects = node.redirects.filter((r) => r.mode !== "<" && r.mode !== "2>&1" && r.mode !== "1>&2");
+      const target = writeRedirects.length > 0 ? await this.expandWordScalar(writeRedirects[writeRedirects.length - 1].target, this.env) : "unknown";
+      await stderr.writeText(`sh: ${target}: ${message}
+`);
+      exitCode = 1;
+    }
+    return exitCode;
+  }
+  async invokeCommand(name, args, stdinSource, stdout, stderr, env) {
     const command = this.commands[name];
-    if (!command) {
-      await stderr.writeText(`${name}: command not found
+    if (command) {
+      return this.invokeRegisteredCommand(name, command, args, stdinSource, stdout, stderr, env);
+    }
+    if (name.includes("/")) {
+      const resolved = this.fs.resolve(this.cwd, name);
+      if (await this.fs.exists(resolved)) {
+        return this.executeExecutableFile(name, args, stdinSource, stdout, stderr, env);
+      }
+      if (this.externalCommand) {
+        return this.invokeExternalCommand(name, args, stdinSource, stdout, stderr, env);
+      }
+      return this.executeExecutableFile(name, args, stdinSource, stdout, stderr, env);
+    }
+    if (this.externalCommand) {
+      return this.invokeExternalCommand(name, args, stdinSource, stdout, stderr, env);
+    }
+    await stderr.writeText(`${name}: command not found
 `);
+    return 127;
+  }
+  async invokeExternalCommand(name, args, stdinSource, stdout, stderr, env) {
+    if (!this.externalCommand) {
       return 127;
     }
-    const exec = async (cmdName, cmdArgs) => {
-      const cmd = this.commands[cmdName];
-      if (!cmd) {
-        return {
-          stdout: Buffer.alloc(0),
-          stderr: Buffer.from(`${cmdName}: command not found
-`),
-          exitCode: 127
-        };
+    const ctx = import_context.createCommandContext({
+      args,
+      stdin: import_stdin.createStdin(stdinSource),
+      stdout,
+      stderr,
+      fs: this.fs,
+      cwd: this.cwd,
+      env,
+      terminal: this.terminal,
+      signal: this.activeSignal,
+      setCwd: (path) => this.setCwd(path),
+      exec: this.createExec(env),
+      shell: this.createShellApi(stdinSource, stdout, stderr, env)
+    });
+    try {
+      return await this.externalCommand({ ...ctx, name });
+    } catch (err) {
+      if (err instanceof BreakException || err instanceof ContinueException || err instanceof ExitException) {
+        throw err;
       }
-      const subStdout = import_stdout.createStdout();
-      const subStderr = import_stdout.createStderr();
-      const subCtx = import_context.createCommandContext({
-        args: cmdArgs,
-        stdin: import_stdin.createStdin(null),
-        stdout: subStdout,
-        stderr: subStderr,
-        fs: this.fs,
-        cwd: this.cwd,
-        env: { ...assignmentEnv },
-        setCwd: (path) => this.setCwd(path),
-        exec
-      });
-      let exitCode2;
-      try {
-        exitCode2 = await cmd(subCtx);
-      } catch (err) {
-        if (err instanceof BreakException || err instanceof ContinueException) {
-          throw err;
-        }
-        const message = err instanceof Error ? err.message : String(err);
-        await subStderr.writeText(`${cmdName}: ${message}
+      if (this.activeSignal.aborted) {
+        throw err;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      await stderr.writeText(`${name}: ${message}
 `);
-        exitCode2 = 1;
+      return 1;
+    }
+  }
+  async invokeRegisteredCommand(name, command, args, stdinSource, stdout, stderr, env) {
+    const exec = this.createExec(env);
+    const shell = this.createShellApi(stdinSource, stdout, stderr, env);
+    const ctx = import_context.createCommandContext({
+      args,
+      stdin: import_stdin.createStdin(stdinSource),
+      stdout,
+      stderr,
+      fs: this.fs,
+      cwd: this.cwd,
+      env,
+      terminal: this.terminal,
+      signal: this.activeSignal,
+      setCwd: (path) => this.setCwd(path),
+      exec,
+      shell
+    });
+    try {
+      return await command(ctx);
+    } catch (err) {
+      if (err instanceof BreakException || err instanceof ContinueException || err instanceof ExitException) {
+        throw err;
       }
+      const message = err instanceof Error ? err.message : String(err);
+      await stderr.writeText(`${name}: ${message}
+`);
+      return 1;
+    }
+  }
+  createExec(env) {
+    return async (name, args) => {
+      const subStdout = import_stdout.createStdout();
+      const subStderr = import_stdout.createStderr();
+      const exitCode = await this.invokeCommand(name, args, null, subStdout, subStderr, { ...env });
       subStdout.close();
       subStderr.close();
       return {
         stdout: await subStdout.collect(),
         stderr: await subStderr.collect(),
-        exitCode: exitCode2
+        exitCode
       };
     };
-    const ctx = import_context.createCommandContext({
-      args,
-      stdin: import_stdin.createStdin(actualStdin),
-      stdout: actualStdout,
-      stderr: actualStderr,
+  }
+  createShellApi(stdinSource, stdout, stderr, env) {
+    return {
+      eval: (source) => this.executeSourceInCurrentFrame(source, stdinSource, stdout, stderr, "eval"),
+      source: (path, args = []) => this.sourceFile(path, args, stdinSource, stdout, stderr),
+      runScript: (path, args = []) => this.executeExecutableFile(path, args, stdinSource, stdout, stderr, { ...env }),
+      runShell: (source, options = {}) => this.executeIsolatedShellSource(source, options.argv0 ?? "sh", options.args ?? [], stdinSource, stdout, stderr, env),
+      getLastExitCode: () => this.lastExitCode,
+      exit: (exitCode = this.lastExitCode) => {
+        throw new ExitException(this.normalizeExitCode(exitCode));
+      }
+    };
+  }
+  async executeExecutableFile(pathName, args, stdinSource, stdout, stderr, env) {
+    const loaded = await this.loadScriptSource(pathName, stderr, 127);
+    if (!loaded.ok) {
+      return loaded.exitCode;
+    }
+    const shebang = this.parseShebang(loaded.source);
+    if (!shebang || shebang.command === "sh") {
+      return this.executeIsolatedShellSource(loaded.source, pathName, args, stdinSource, stdout, stderr, env);
+    }
+    const command = this.commands[shebang.command];
+    if (!command) {
+      await stderr.writeText(`${pathName}: unsupported interpreter: ${shebang.display}
+`);
+      return 126;
+    }
+    const child = new Interpreter({
       fs: this.fs,
       cwd: this.cwd,
-      env: assignmentEnv,
-      setCwd: (path) => this.setCwd(path),
-      exec
+      env: { ...env },
+      commands: this.commands,
+      redirectObjects: this.redirectObjects,
+      terminal: this.terminal,
+      externalCommand: this.externalCommand,
+      signal: this.activeSignal,
+      argv0: shebang.command,
+      positionalParameters: []
     });
-    let exitCode;
+    return child.invokeRegisteredCommand(shebang.command, command, [...shebang.args, pathName, ...args], stdinSource, stdout, stderr, { ...env });
+  }
+  async sourceFile(pathName, args, stdinSource, stdout, stderr) {
+    const loaded = await this.loadScriptSource(pathName, stderr, 1);
+    if (!loaded.ok) {
+      return loaded.exitCode;
+    }
+    return this.executeSourceInCurrentFrame(loaded.source, stdinSource, stdout, stderr, pathName, args.length > 0 ? { args } : undefined);
+  }
+  async executeIsolatedShellSource(source, argv0, args, stdinSource, stdout, stderr, env) {
+    const interpreter = new Interpreter({
+      fs: this.fs,
+      cwd: this.cwd,
+      env: { ...env },
+      commands: this.commands,
+      redirectObjects: this.redirectObjects,
+      terminal: this.terminal,
+      externalCommand: this.externalCommand,
+      signal: this.activeSignal,
+      argv0,
+      positionalParameters: args
+    });
+    try {
+      return await interpreter.executeSourceInCurrentFrame(source, stdinSource, stdout, stderr, argv0);
+    } catch (err) {
+      if (err instanceof ExitException) {
+        return err.exitCode;
+      }
+      throw err;
+    }
+  }
+  async executeSourceInCurrentFrame(source, stdinSource, stdout, stderr, errorName, positionalOverride) {
+    const previousArgv0 = this.argv0;
+    const previousPositionals = this.positionalParameters;
+    if (positionalOverride?.argv0 !== undefined) {
+      this.argv0 = positionalOverride.argv0;
+    }
+    if (positionalOverride?.args !== undefined) {
+      this.positionalParameters = [...positionalOverride.args];
+    }
     try {
-      exitCode = await command(ctx);
+      const ast = this.parseSource(source);
+      if (!ast) {
+        return 0;
+      }
+      return await this.executeNode(ast, stdinSource, stdout, stderr);
     } catch (err) {
-      if (err instanceof BreakException || err instanceof ContinueException) {
+      if (err instanceof BreakException || err instanceof ContinueException || err instanceof ExitException) {
         throw err;
       }
       const message = err instanceof Error ? err.message : String(err);
-      await stderr.writeText(`${name}: ${message}
+      await stderr.writeText(`${errorName}: ${message}
 `);
-      exitCode = 1;
+      return 2;
+    } finally {
+      if (positionalOverride?.argv0 !== undefined) {
+        this.argv0 = previousArgv0;
+      }
+      if (positionalOverride?.args !== undefined) {
+        this.positionalParameters = previousPositionals;
+      }
     }
-    if (actualStdout !== stdout) {
-      actualStdout.close();
+  }
+  parseSource(source) {
+    const tokens = new import_lexer.Lexer(source, { preserveNewlines: true }).tokenize();
+    if (tokens.every((token) => token.type === "newline" || token.type === "eof")) {
+      return null;
     }
-    if (actualStderr !== stderr && actualStderr !== actualStdout) {
-      actualStderr.close();
+    return new import_parser.Parser(tokens).parse();
+  }
+  async loadScriptSource(pathName, stderr, missingExitCode) {
+    const path = this.fs.resolve(this.cwd, pathName);
+    if (!await this.fs.exists(path)) {
+      await stderr.writeText(`${pathName}: No such file or directory
+`);
+      return { ok: false, exitCode: missingExitCode };
+    }
+    const stat = await this.fs.stat(path);
+    if (stat.isDirectory()) {
+      await stderr.writeText(`${pathName}: is a directory
+`);
+      return { ok: false, exitCode: 126 };
+    }
+    if (!stat.isFile()) {
+      await stderr.writeText(`${pathName}: not a file
+`);
+      return { ok: false, exitCode: 126 };
     }
     try {
-      await Promise.all(fileWritePromises);
+      return { ok: true, path, source: await this.fs.readFile(path, "utf-8") };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const writeRedirects = node.redirects.filter((r) => r.mode !== "<" && r.mode !== "2>&1" && r.mode !== "1>&2");
-      const target = writeRedirects.length > 0 ? await this.expandWordScalar(writeRedirects[writeRedirects.length - 1].target, this.env) : "unknown";
-      await stderr.writeText(`sh: ${target}: ${message}
+      await stderr.writeText(`${pathName}: ${message}
 `);
-      exitCode = 1;
+      return { ok: false, exitCode: 126 };
     }
-    return exitCode;
+  }
+  parseShebang(source) {
+    if (!source.startsWith("#!")) {
+      return null;
+    }
+    const lineEnd = source.indexOf(`
+`);
+    const line = source.slice(2, lineEnd === -1 ? undefined : lineEnd).trim();
+    if (line === "") {
+      return { command: "sh", args: [], display: "sh" };
+    }
+    const parts = line.split(/\s+/);
+    const executable = parts[0];
+    const executableName = this.fs.basename(executable);
+    if (executableName === "env") {
+      const envCommand = parts[1];
+      if (!envCommand) {
+        return { command: "env", args: [], display: line };
+      }
+      return {
+        command: this.fs.basename(envCommand),
+        args: parts.slice(2),
+        display: line
+      };
+    }
+    return {
+      command: executableName,
+      args: parts.slice(1),
+      display: line
+    };
   }
   async handleRedirect(redirect, stdin, stdout, stderr, env) {
     const target = await this.expandWordScalar(redirect.target, env);
@@ -672,6 +977,10 @@ class Interpreter {
         this.appendSegment(fields[fields.length - 1], part.value, part.quoted);
         continue;
       }
+      if (part.type === "variable" && part.name === "@" && part.quoted) {
+        this.appendQuotedPositionalParameters(fields);
+        continue;
+      }
       const value = await this.expandWordPart(part, env);
       if (part.quoted) {
         this.appendSegment(fields[fields.length - 1], value, true);
@@ -695,7 +1004,7 @@ class Interpreter {
       case "text":
         return part.value;
       case "variable":
-        return env[part.name] ?? "";
+        return this.getVariableValue(part.name, env);
       case "substitution":
         return this.executeSubstitution(part.command, env);
       case "arithmetic":
@@ -704,6 +1013,35 @@ class Interpreter {
         throw new Error("Cannot expand unknown word part");
     }
   }
+  getVariableValue(name, env) {
+    if (name === "0") {
+      return this.argv0;
+    }
+    if (name === "#") {
+      return String(this.positionalParameters.length);
+    }
+    if (name === "?") {
+      return String(this.lastExitCode);
+    }
+    if (name === "*" || name === "@") {
+      return this.positionalParameters.join(" ");
+    }
+    if (/^[1-9]$/.test(name)) {
+      return this.positionalParameters[Number(name) - 1] ?? "";
+    }
+    return env[name] ?? "";
+  }
+  appendQuotedPositionalParameters(fields) {
+    if (this.positionalParameters.length === 0) {
+      return;
+    }
+    this.appendSegment(fields[fields.length - 1], this.positionalParameters[0], true);
+    for (let i = 1;i < this.positionalParameters.length; i++) {
+      const field = this.createExpandedField();
+      this.appendSegment(field, this.positionalParameters[i], true);
+      fields.push(field);
+    }
+  }
   async executeSubstitution(command, env) {
     const interpreter = new Interpreter({
       fs: this.fs,
@@ -711,7 +1049,12 @@ class Interpreter {
       env,
       commands: this.commands,
       redirectObjects: this.redirectObjects,
-      isTTY: false
+      isTTY: false,
+      externalCommand: this.externalCommand,
+      signal: this.activeSignal,
+      argv0: this.argv0,
+      positionalParameters: this.positionalParameters,
+      lastExitCode: this.lastExitCode
     });
     const result = await interpreter.execute(command);
     return result.stdout.toString("utf-8").replace(/\n+$/, "");
@@ -812,8 +1155,8 @@ class Interpreter {
     expandedExpr = expandedExpr.replace(/\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_, name) => {
       return env[name] ?? "0";
     });
-    expandedExpr = expandedExpr.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, name) => {
-      return env[name] ?? "0";
+    expandedExpr = expandedExpr.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*|[0-9#*@?])/g, (_, name) => {
+      return this.getVariableValue(name, env) || "0";
     });
     expandedExpr = expandedExpr.replace(/\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g, (match) => {
       if (/^\d+$/.test(match))
@@ -970,6 +1313,12 @@ class Interpreter {
     };
     return parseOr();
   }
+  normalizeExitCode(exitCode) {
+    if (!Number.isFinite(exitCode)) {
+      return 2;
+    }
+    return (Math.trunc(exitCode) % 256 + 256) % 256;
+  }
   setCwd(cwd) {
     this.env.OLDPWD = this.cwd;
     this.cwd = cwd;
@@ -983,6 +1332,9 @@ class Interpreter {
   getEnv() {
     return { ...this.env };
   }
+  getLastExitCode() {
+    return this.lastExitCode;
+  }
 }
 
-//# debugId=1238E19B5ED5404064756E2164756E21
+//# debugId=F9FD7440AC6CB03664756E2164756E21