@machina.at/xsh 19.81.0

package/main.cjs

@@ -0,0 +1,4875 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// projects/@machina.at/shell/src/commands/ls.js
+var require_ls = __commonJS({
+  "projects/@machina.at/shell/src/commands/ls.js"(exports2, module2) {
+    "use strict";
+    function formatMode(mode, isDir, isLink) {
+      var type = isDir ? "d" : isLink ? "l" : "-";
+      var perms = "";
+      for (var i = 2; i >= 0; i--) {
+        var shift = i * 3;
+        perms += mode & 4 << shift ? "r" : "-";
+        perms += mode & 2 << shift ? "w" : "-";
+        perms += mode & 1 << shift ? "x" : "-";
+      }
+      return type + perms;
+    }
+    function pad(s, n, alignLeft) {
+      s = String(s);
+      while (s.length < n) s = alignLeft ? s + " " : " " + s;
+      return s;
+    }
+    function pad2(n) {
+      return n < 10 ? "0" + n : String(n);
+    }
+    module2.exports = function ls(args, ctx) {
+      var showAll = false;
+      var longFormat = false;
+      var targets = [];
+      for (var i = 0; i < args.length; i++) {
+        var a = args[i];
+        if (a === "-a" || a === "--all" || a === "-A") {
+          showAll = true;
+        } else if (a === "-l") {
+          longFormat = true;
+        } else if (a === "-la" || a === "-al" || a === "-lA" || a === "-Al") {
+          showAll = true;
+          longFormat = true;
+        } else if (!a.startsWith("-")) {
+          targets.push(a);
+        }
+      }
+      if (targets.length === 0) targets.push(".");
+      var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+      function fmtEntry(name, stat2) {
+        var isDir = stat2.isDirectory && stat2.isDirectory();
+        var isLink = stat2.isSymbolicLink && stat2.isSymbolicLink();
+        if (!longFormat) {
+          var suffix = isDir ? "/" : "";
+          return name + suffix + "\n";
+        }
+        var mode = typeof stat2.mode === "number" ? stat2.mode : isDir ? 493 : 420;
+        var perms = formatMode(mode, isDir, isLink);
+        var nlink = stat2.nlink || 1;
+        var uid = stat2.uid || 0;
+        var gid = stat2.gid || 0;
+        var size = typeof stat2.size === "number" ? stat2.size : 0;
+        var mtime;
+        if (stat2.mtime) mtime = new Date(stat2.mtime);
+        else if (typeof stat2.mtimeMs === "number") mtime = new Date(stat2.mtimeMs);
+        else mtime = /* @__PURE__ */ new Date();
+        var dateStr = months[mtime.getMonth()] + " " + pad(mtime.getDate(), 2) + " " + pad2(mtime.getHours()) + ":" + pad2(mtime.getMinutes());
+        var suffix2 = isDir ? "/" : "";
+        return perms + " " + pad(nlink, 3) + " " + pad(uid, 6, true) + " " + pad(gid, 6, true) + " " + pad(size, 8) + " " + dateStr + " " + name + suffix2 + "\n";
+      }
+      for (var t = 0; t < targets.length; t++) {
+        var target = targets[t];
+        var fullPath = target.startsWith("/") ? target : ctx.path.join(ctx.cwd, target);
+        try {
+          var fstat = ctx.fs.statSync(fullPath);
+          if (!fstat.isDirectory()) {
+            process.stdout.write(fmtEntry(target, fstat));
+            continue;
+          }
+          if (showAll && longFormat) {
+            try {
+              var dotStat = ctx.fs.statSync(fullPath);
+              process.stdout.write(fmtEntry(".", dotStat));
+            } catch (e) {
+            }
+            try {
+              var parentStat = ctx.fs.statSync(ctx.path.join(fullPath, ".."));
+              process.stdout.write(fmtEntry("..", parentStat));
+            } catch (e) {
+            }
+          }
+          var entries = ctx.fs.readdirSync(fullPath);
+          for (var j = 0; j < entries.length; j++) {
+            var entry = entries[j];
+            if (!showAll && entry.startsWith(".")) continue;
+            try {
+              var stat = ctx.fs.statSync(ctx.path.join(fullPath, entry));
+              process.stdout.write(fmtEntry(entry, stat));
+            } catch (e) {
+              process.stdout.write(entry + "\n");
+            }
+          }
+        } catch (err2) {
+          process.stderr.write("ls: " + target + ": " + err2.message + "\n");
+          return 1;
+        }
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/cat.js
+var require_cat = __commonJS({
+  "projects/@machina.at/shell/src/commands/cat.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function cat2(args, ctx) {
+      if (args.length === 0) {
+        if (ctx.stdin) {
+          process.stdout.write(ctx.stdin);
+          return 0;
+        }
+        process.stderr.write("cat: missing file operand\n");
+        return 1;
+      }
+      for (var i = 0; i < args.length; i++) {
+        var filePath = args[i].startsWith("/") ? args[i] : ctx.path.join(ctx.cwd, args[i]);
+        try {
+          var content = ctx.fs.readFileSync(filePath);
+          if (typeof content === "string") {
+            process.stdout.write(content);
+          } else {
+            process.stdout.write(new TextDecoder().decode(content));
+          }
+        } catch (err2) {
+          process.stderr.write("cat: " + args[i] + ": " + err2.message + "\n");
+          return 1;
+        }
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/echo.js
+var require_echo = __commonJS({
+  "projects/@machina.at/shell/src/commands/echo.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function echo(args) {
+      var noNewline = false;
+      var escapes = false;
+      var start = 0;
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-n") {
+          noNewline = true;
+          start = i + 1;
+        } else if (args[i] === "-e") {
+          escapes = true;
+          start = i + 1;
+        } else if (args[i] === "-ne" || args[i] === "-en") {
+          noNewline = true;
+          escapes = true;
+          start = i + 1;
+        } else {
+          break;
+        }
+      }
+      var output = args.slice(start).join(" ");
+      if (escapes) {
+        output = output.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\\\/g, "\\");
+      }
+      process.stdout.write(output + (noNewline ? "" : "\n"));
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/pwd.js
+var require_pwd = __commonJS({
+  "projects/@machina.at/shell/src/commands/pwd.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function pwd(args, ctx) {
+      process.stdout.write(ctx.cwd + "\n");
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/mkdir.js
+var require_mkdir = __commonJS({
+  "projects/@machina.at/shell/src/commands/mkdir.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function mkdir(args, ctx) {
+      if (args.length === 0) {
+        process.stderr.write("mkdir: missing operand\n");
+        return 1;
+      }
+      var recursive = false;
+      var dirs = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-p") {
+          recursive = true;
+        } else if (!args[i].startsWith("-")) {
+          dirs.push(args[i]);
+        }
+      }
+      for (var j = 0; j < dirs.length; j++) {
+        var dirPath = dirs[j].startsWith("/") ? dirs[j] : ctx.path.join(ctx.cwd, dirs[j]);
+        try {
+          ctx.fs.mkdirSync(dirPath, { recursive });
+        } catch (err2) {
+          process.stderr.write("mkdir: " + dirs[j] + ": " + err2.message + "\n");
+          return 1;
+        }
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/head.js
+var require_head = __commonJS({
+  "projects/@machina.at/shell/src/commands/head.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function head2(args, ctx) {
+      var lines = 10;
+      var files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-n" && args[i + 1]) {
+          lines = parseInt(args[++i], 10);
+        } else if (args[i].startsWith("-n")) {
+          lines = parseInt(args[i].substring(2), 10);
+        } else if (/^-\d+$/.test(args[i])) {
+          lines = parseInt(args[i].substring(1), 10);
+        } else if (!args[i].startsWith("-")) {
+          files.push(args[i]);
+        }
+      }
+      if (files.length === 0) {
+        if (ctx.stdin) {
+          var stdinResult = ctx.stdin.split("\n").slice(0, lines).join("\n");
+          if (!stdinResult.endsWith("\n")) stdinResult += "\n";
+          process.stdout.write(stdinResult);
+          return 0;
+        }
+        process.stderr.write("head: missing file operand\n");
+        return 1;
+      }
+      for (var j = 0; j < files.length; j++) {
+        var filePath = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          var content = ctx.fs.readFileSync(filePath);
+          var text = typeof content === "string" ? content : new TextDecoder().decode(content);
+          var result = text.split("\n").slice(0, lines).join("\n");
+          process.stdout.write(result + "\n");
+        } catch (err2) {
+          process.stderr.write("head: " + files[j] + ": " + err2.message + "\n");
+          return 1;
+        }
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/tail.js
+var require_tail = __commonJS({
+  "projects/@machina.at/shell/src/commands/tail.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function tail2(args, ctx) {
+      var lines = 10;
+      var files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-n" && args[i + 1]) {
+          lines = parseInt(args[++i], 10);
+        } else if (args[i].startsWith("-n")) {
+          lines = parseInt(args[i].substring(2), 10);
+        } else if (!args[i].startsWith("-")) {
+          files.push(args[i]);
+        }
+      }
+      if (files.length === 0) {
+        if (ctx.stdin) {
+          var stdinAll = ctx.stdin.split("\n");
+          if (stdinAll[stdinAll.length - 1] === "") stdinAll.pop();
+          var stdinResult = stdinAll.slice(-lines).join("\n");
+          if (!stdinResult.endsWith("\n")) stdinResult += "\n";
+          process.stdout.write(stdinResult);
+          return 0;
+        }
+        process.stderr.write("tail: missing file operand\n");
+        return 1;
+      }
+      for (var j = 0; j < files.length; j++) {
+        var filePath = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          var content = ctx.fs.readFileSync(filePath);
+          var text = typeof content === "string" ? content : new TextDecoder().decode(content);
+          var result = text.split("\n").slice(-lines).join("\n");
+          process.stdout.write(result + "\n");
+        } catch (err2) {
+          process.stderr.write("tail: " + files[j] + ": " + err2.message + "\n");
+          return 1;
+        }
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/env.js
+var require_env = __commonJS({
+  "projects/@machina.at/shell/src/commands/env.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function env(args, ctx) {
+      var keys = Object.keys(ctx.env);
+      for (var i = 0; i < keys.length; i++) {
+        process.stdout.write(keys[i] + "=" + ctx.env[keys[i]] + "\n");
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/which.js
+var require_which = __commonJS({
+  "projects/@machina.at/shell/src/commands/which.js"(exports2, module2) {
+    "use strict";
+    var commandNames = require_commands();
+    var shellBuiltins = [
+      "cd",
+      "export",
+      "exit",
+      "set",
+      "unset",
+      "read",
+      "source",
+      "shift",
+      "type",
+      "local",
+      "command",
+      "getopts"
+    ];
+    module2.exports = function which(args) {
+      if (args.length === 0) return 0;
+      var exitCode = 0;
+      for (var i = 0; i < args.length; i++) {
+        var name = args[i];
+        if (commandNames[name]) {
+          process.stdout.write(name + ": /bin/commands/" + name + ".js\n");
+        } else if (shellBuiltins.indexOf(name) !== -1) {
+          process.stdout.write(name + ": shell built-in\n");
+        } else {
+          process.stderr.write("which: " + name + ": not found\n");
+          exitCode = 1;
+        }
+      }
+      return exitCode;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/help.js
+var require_help = __commonJS({
+  "projects/@machina.at/shell/src/commands/help.js"(exports2, module2) {
+    "use strict";
+    var DESCRIPTIONS = {
+      ls: "List directory contents",
+      cat: "Concatenate and print files",
+      echo: "Display a line of text",
+      pwd: "Print working directory",
+      cd: "Change directory (built-in)",
+      mkdir: "Make directories",
+      head: "Output first part of files",
+      tail: "Output last part of files",
+      env: "Print environment",
+      export: "Set environment variable (built-in)",
+      which: "Locate a command",
+      help: "Display this help",
+      clear: "Clear the terminal screen",
+      exit: "Exit the shell (built-in)"
+    };
+    module2.exports = function help(args, ctx) {
+      process.stdout.write("Available commands:\n");
+      var names = Object.keys(DESCRIPTIONS);
+      for (var i = 0; i < names.length; i++) {
+        var name = names[i];
+        var pad = "          ".substring(0, 10 - name.length);
+        process.stdout.write("  " + name + pad + " - " + DESCRIPTIONS[name] + "\n");
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/clear.js
+var require_clear = __commonJS({
+  "projects/@machina.at/shell/src/commands/clear.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function clear(args, ctx) {
+      process.stdout.write("\x1B[2J\x1B[H");
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/test.js
+var require_test = __commonJS({
+  "projects/@machina.at/shell/src/commands/test.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function test(args, ctx) {
+      if (args.length > 0 && args[args.length - 1] === "]") {
+        args = args.slice(0, -1);
+      } else if (module2.exports._bracketMode) {
+        ctx.stderr && ctx.stderr.write("test: missing ]\n");
+        return 2;
+      }
+      if (args.length === 0) return 1;
+      if (args[0] === "!") {
+        var inner = evaluate(args.slice(1), ctx);
+        return inner === 0 ? 1 : 0;
+      }
+      return evaluate(args, ctx);
+    };
+    function evaluate(args, ctx) {
+      if (args.length === 0) return 1;
+      if (args.length === 1) {
+        return args[0] ? 0 : 1;
+      }
+      if (args.length === 2) {
+        return evalUnary(args[0], args[1], ctx);
+      }
+      if (args.length === 3) {
+        return evalBinary(args[0], args[1], args[2], ctx);
+      }
+      return 1;
+    }
+    function resolvePath(p, ctx) {
+      if (p.startsWith("/")) return p;
+      return ctx.path.join(ctx.cwd, p);
+    }
+    function evalUnary(op, operand, ctx) {
+      var filePath = resolvePath(operand, ctx);
+      switch (op) {
+        case "-e":
+          return ctx.fs.existsSync(filePath) ? 0 : 1;
+        case "-f":
+          try {
+            return ctx.fs.statSync(filePath).isFile() ? 0 : 1;
+          } catch (_) {
+            return 1;
+          }
+        case "-d":
+          try {
+            return ctx.fs.statSync(filePath).isDirectory() ? 0 : 1;
+          } catch (_) {
+            return 1;
+          }
+        case "-s":
+          try {
+            return ctx.fs.statSync(filePath).size > 0 ? 0 : 1;
+          } catch (_) {
+            return 1;
+          }
+        case "-r":
+          try {
+            return ctx.fs.statSync(filePath).mode & 292 ? 0 : 1;
+          } catch (_) {
+            return 1;
+          }
+        case "-w":
+          try {
+            return ctx.fs.statSync(filePath).mode & 146 ? 0 : 1;
+          } catch (_) {
+            return 1;
+          }
+        case "-x":
+          try {
+            return ctx.fs.statSync(filePath).mode & 73 ? 0 : 1;
+          } catch (_) {
+            return 1;
+          }
+        case "-z":
+          return operand.length === 0 ? 0 : 1;
+        case "-n":
+          return operand.length > 0 ? 0 : 1;
+        default:
+          return 1;
+      }
+    }
+    function evalBinary(left, op, right) {
+      switch (op) {
+        case "=":
+          return left === right ? 0 : 1;
+        case "!=":
+          return left !== right ? 0 : 1;
+        case "-eq":
+          return parseInt(left, 10) === parseInt(right, 10) ? 0 : 1;
+        case "-ne":
+          return parseInt(left, 10) !== parseInt(right, 10) ? 0 : 1;
+        case "-lt":
+          return parseInt(left, 10) < parseInt(right, 10) ? 0 : 1;
+        case "-le":
+          return parseInt(left, 10) <= parseInt(right, 10) ? 0 : 1;
+        case "-gt":
+          return parseInt(left, 10) > parseInt(right, 10) ? 0 : 1;
+        case "-ge":
+          return parseInt(left, 10) >= parseInt(right, 10) ? 0 : 1;
+        default:
+          return 1;
+      }
+    }
+  }
+});
+
+// projects/@machina.at/shell/src/commands/true.js
+var require_true = __commonJS({
+  "projects/@machina.at/shell/src/commands/true.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function _true() {
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/false.js
+var require_false = __commonJS({
+  "projects/@machina.at/shell/src/commands/false.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function _false() {
+      return 1;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/cp.js
+var require_cp = __commonJS({
+  "projects/@machina.at/shell/src/commands/cp.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function cp2(args, ctx) {
+      var recursive = false;
+      var paths = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-r" || args[i] === "-R" || args[i] === "-rf" || args[i] === "-fr") recursive = true;
+        else if (args[i] === "-f") {
+        } else if (!args[i].startsWith("-")) paths.push(args[i]);
+      }
+      if (paths.length < 2) {
+        process.stderr.write("cp: missing file operand\n");
+        return 1;
+      }
+      var src = paths[0].startsWith("/") ? paths[0] : ctx.path.join(ctx.cwd, paths[0]);
+      var dst = paths[1].startsWith("/") ? paths[1] : ctx.path.join(ctx.cwd, paths[1]);
+      try {
+        var stat = ctx.fs.statSync(src);
+        if (stat.isDirectory()) {
+          if (!recursive) {
+            process.stderr.write("cp: -r not specified; omitting directory '" + paths[0] + "'\n");
+            return 1;
+          }
+          cpDir(src, dst, ctx);
+        } else {
+          ctx.fs.writeFileSync(dst, ctx.fs.readFileSync(src));
+        }
+        return 0;
+      } catch (err2) {
+        process.stderr.write("cp: " + paths[0] + ": " + err2.message + "\n");
+        return 1;
+      }
+    };
+    function cpDir(src, dst, ctx) {
+      try {
+        ctx.fs.mkdirSync(dst);
+      } catch (_) {
+      }
+      var entries = ctx.fs.readdirSync(src);
+      for (var i = 0; i < entries.length; i++) {
+        var s = ctx.path.join(src, entries[i]), d = ctx.path.join(dst, entries[i]);
+        if (ctx.fs.statSync(s).isDirectory()) cpDir(s, d, ctx);
+        else ctx.fs.writeFileSync(d, ctx.fs.readFileSync(s));
+      }
+    }
+  }
+});
+
+// projects/@machina.at/shell/src/commands/mv.js
+var require_mv = __commonJS({
+  "projects/@machina.at/shell/src/commands/mv.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function mv2(args, ctx) {
+      var paths = [];
+      for (var i = 0; i < args.length; i++) {
+        if (!args[i].startsWith("-")) paths.push(args[i]);
+      }
+      if (paths.length < 2) {
+        process.stderr.write("mv: missing file operand\n");
+        return 1;
+      }
+      var src = paths[0].startsWith("/") ? paths[0] : ctx.path.join(ctx.cwd, paths[0]);
+      var dst = paths[1].startsWith("/") ? paths[1] : ctx.path.join(ctx.cwd, paths[1]);
+      try {
+        ctx.fs.renameSync(src, dst);
+        return 0;
+      } catch (err2) {
+        process.stderr.write("mv: " + paths[0] + ": " + err2.message + "\n");
+        return 1;
+      }
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/rm.js
+var require_rm = __commonJS({
+  "projects/@machina.at/shell/src/commands/rm.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function rm2(args, ctx) {
+      var recursive = false, force = false, targets = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-r" || args[i] === "-R") recursive = true;
+        else if (args[i] === "-f") force = true;
+        else if (args[i] === "-rf" || args[i] === "-fr") {
+          recursive = true;
+          force = true;
+        } else if (!args[i].startsWith("-")) targets.push(args[i]);
+      }
+      if (targets.length === 0) {
+        if (!force) {
+          process.stderr.write("rm: missing operand\n");
+          return 1;
+        }
+        return 0;
+      }
+      for (var j = 0; j < targets.length; j++) {
+        var p = targets[j].startsWith("/") ? targets[j] : ctx.path.join(ctx.cwd, targets[j]);
+        try {
+          var stat = ctx.fs.statSync(p);
+          if (stat.isDirectory()) {
+            if (!recursive) {
+              process.stderr.write("rm: cannot remove '" + targets[j] + "': Is a directory\n");
+              return 1;
+            }
+            rmDir2(p, ctx);
+          } else {
+            ctx.fs.unlinkSync(p);
+          }
+        } catch (err2) {
+          if (!force) {
+            process.stderr.write("rm: " + targets[j] + ": " + err2.message + "\n");
+            return 1;
+          }
+        }
+      }
+      return 0;
+    };
+    function rmDir2(p, ctx) {
+      var entries = ctx.fs.readdirSync(p);
+      for (var i = 0; i < entries.length; i++) {
+        var full = ctx.path.join(p, entries[i]);
+        if (ctx.fs.statSync(full).isDirectory()) rmDir2(full, ctx);
+        else ctx.fs.unlinkSync(full);
+      }
+      ctx.fs.rmdirSync(p);
+    }
+  }
+});
+
+// projects/@machina.at/shell/src/commands/rmdir.js
+var require_rmdir = __commonJS({
+  "projects/@machina.at/shell/src/commands/rmdir.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function rmdir2(args, ctx) {
+      if (args.length === 0) {
+        process.stderr.write("rmdir: missing operand\n");
+        return 1;
+      }
+      for (var i = 0; i < args.length; i++) {
+        if (args[i].startsWith("-")) continue;
+        var p = args[i].startsWith("/") ? args[i] : ctx.path.join(ctx.cwd, args[i]);
+        try {
+          var entries = ctx.fs.readdirSync(p);
+          if (entries.length > 0) {
+            process.stderr.write("rmdir: " + args[i] + ": Directory not empty\n");
+            return 1;
+          }
+          ctx.fs.rmdirSync(p);
+        } catch (err2) {
+          process.stderr.write("rmdir: " + args[i] + ": " + err2.message + "\n");
+          return 1;
+        }
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/touch.js
+var require_touch = __commonJS({
+  "projects/@machina.at/shell/src/commands/touch.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function touch2(args, ctx) {
+      if (args.length === 0) {
+        process.stderr.write("touch: missing file operand\n");
+        return 1;
+      }
+      for (var i = 0; i < args.length; i++) {
+        if (args[i].startsWith("-")) continue;
+        var p = args[i].startsWith("/") ? args[i] : ctx.path.join(ctx.cwd, args[i]);
+        try {
+          if (ctx.fs.existsSync(p)) {
+            ctx.fs.utimesSync(p, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+          } else {
+            ctx.fs.writeFileSync(p, "");
+          }
+        } catch (err2) {
+          process.stderr.write("touch: " + args[i] + ": " + err2.message + "\n");
+          return 1;
+        }
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/ln.js
+var require_ln = __commonJS({
+  "projects/@machina.at/shell/src/commands/ln.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function ln2(args, ctx) {
+      var symbolic = false, paths = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-s") symbolic = true;
+        else if (!args[i].startsWith("-")) paths.push(args[i]);
+      }
+      if (paths.length < 2) {
+        process.stderr.write("ln: missing file operand\n");
+        return 1;
+      }
+      var target = paths[0].startsWith("/") ? paths[0] : ctx.path.join(ctx.cwd, paths[0]);
+      var linkName = paths[1].startsWith("/") ? paths[1] : ctx.path.join(ctx.cwd, paths[1]);
+      try {
+        if (symbolic) ctx.fs.symlinkSync(target, linkName);
+        else ctx.fs.linkSync(target, linkName);
+        return 0;
+      } catch (err2) {
+        process.stderr.write("ln: " + paths[1] + ": " + err2.message + "\n");
+        return 1;
+      }
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/grep.js
+var require_grep = __commonJS({
+  "projects/@machina.at/shell/src/commands/grep.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function grep2(args, ctx) {
+      var invert = false, ignoreCase = false, countOnly = false, lineNum = false;
+      var pattern = "", patternSet = false, files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-v") invert = true;
+        else if (args[i] === "-i") ignoreCase = true;
+        else if (args[i] === "-c") countOnly = true;
+        else if (args[i] === "-n") lineNum = true;
+        else if (args[i].startsWith("-")) {
+        } else if (!patternSet) {
+          pattern = args[i];
+          patternSet = true;
+        } else files.push(args[i]);
+      }
+      if (!patternSet) {
+        process.stderr.write("grep: missing pattern\n");
+        return 2;
+      }
+      var input = files.length === 0 ? ctx.stdin || "" : "";
+      for (var j = 0; j < files.length; j++) {
+        var p = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          input += ctx.fs.readFileSync(p);
+        } catch (e) {
+          process.stderr.write(files[j] + ": " + e.message + "\n");
+          return 1;
+        }
+      }
+      var re = new RegExp(pattern, ignoreCase ? "i" : "");
+      var lines = input.split("\n");
+      if (lines[lines.length - 1] === "") lines.pop();
+      var count = 0, matched = [];
+      for (var k = 0; k < lines.length; k++) {
+        var m = re.test(lines[k]);
+        if (m !== invert) {
+          count++;
+          matched.push(lineNum ? k + 1 + ":" + lines[k] : lines[k]);
+        }
+      }
+      if (countOnly) process.stdout.write(count + "\n");
+      else for (var l = 0; l < matched.length; l++) process.stdout.write(matched[l] + "\n");
+      return count > 0 ? 0 : 1;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/sed.js
+var require_sed = __commonJS({
+  "projects/@machina.at/shell/src/commands/sed.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function sed2(args, ctx) {
+      var expression = "", files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (!args[i].startsWith("-") && !expression) expression = args[i];
+        else if (!args[i].startsWith("-")) files.push(args[i]);
+      }
+      if (!expression) {
+        process.stderr.write("sed: missing expression\n");
+        return 1;
+      }
+      var input = files.length === 0 ? ctx.stdin || "" : "";
+      for (var j = 0; j < files.length; j++) {
+        var p = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          input += ctx.fs.readFileSync(p);
+        } catch (e) {
+          process.stderr.write(files[j] + ": " + e.message + "\n");
+          return 1;
+        }
+      }
+      var m = expression.match(/^s(.)(.+?)\1(.*?)\1([g]?)$/);
+      if (!m) {
+        process.stderr.write("sed: invalid expression: " + expression + "\n");
+        return 1;
+      }
+      var re = new RegExp(m[2], m[4] === "g" ? "g" : "");
+      var lines = input.split("\n");
+      for (var k = 0; k < lines.length; k++) {
+        process.stdout.write(lines[k].replace(re, m[3]) + (k < lines.length - 1 ? "\n" : ""));
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/wc.js
+var require_wc = __commonJS({
+  "projects/@machina.at/shell/src/commands/wc.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function wc2(args, ctx) {
+      var lo = false, wo = false, co = false, files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-l") lo = true;
+        else if (args[i] === "-w") wo = true;
+        else if (args[i] === "-c" || args[i] === "-m") co = true;
+        else if (!args[i].startsWith("-")) files.push(args[i]);
+      }
+      var input = files.length === 0 ? ctx.stdin || "" : "";
+      for (var j = 0; j < files.length; j++) {
+        var p = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          input += ctx.fs.readFileSync(p);
+        } catch (e) {
+          process.stderr.write(files[j] + ": " + e.message + "\n");
+          return 1;
+        }
+      }
+      var lc = input.split("\n").length - (input.endsWith("\n") ? 1 : 0);
+      var wt = input.trim() ? input.trim().split(/\s+/).length : 0;
+      var cc = input.length;
+      if (lo) process.stdout.write(lc + "\n");
+      else if (wo) process.stdout.write(wt + "\n");
+      else if (co) process.stdout.write(cc + "\n");
+      else process.stdout.write(lc + " " + wt + " " + cc + "\n");
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/sort.js
+var require_sort = __commonJS({
+  "projects/@machina.at/shell/src/commands/sort.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function sort2(args, ctx) {
+      var rev3 = false, num = false, uniq2 = false, files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-r") rev3 = true;
+        else if (args[i] === "-n") num = true;
+        else if (args[i] === "-u") uniq2 = true;
+        else if (!args[i].startsWith("-")) files.push(args[i]);
+      }
+      var input = files.length === 0 ? ctx.stdin || "" : "";
+      for (var j = 0; j < files.length; j++) {
+        var p = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          input += ctx.fs.readFileSync(p);
+        } catch (e) {
+          process.stderr.write(files[j] + ": " + e.message + "\n");
+          return 1;
+        }
+      }
+      var lines = input.split("\n");
+      if (lines[lines.length - 1] === "") lines.pop();
+      if (num) lines.sort(function(a, b) {
+        return parseFloat(a) - parseFloat(b);
+      });
+      else lines.sort();
+      if (rev3) lines.reverse();
+      if (uniq2) {
+        var s = {};
+        lines = lines.filter(function(l) {
+          if (s[l]) return false;
+          s[l] = 1;
+          return true;
+        });
+      }
+      for (var k = 0; k < lines.length; k++) process.stdout.write(lines[k] + "\n");
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/uniq.js
+var require_uniq = __commonJS({
+  "projects/@machina.at/shell/src/commands/uniq.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function uniq2(args, ctx) {
+      var countP = false, dupsOnly = false, files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-c") countP = true;
+        else if (args[i] === "-d") dupsOnly = true;
+        else if (!args[i].startsWith("-")) files.push(args[i]);
+      }
+      var input = files.length === 0 ? ctx.stdin || "" : "";
+      for (var j = 0; j < files.length; j++) {
+        var p = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          input += ctx.fs.readFileSync(p);
+        } catch (e) {
+          process.stderr.write(files[j] + ": " + e.message + "\n");
+          return 1;
+        }
+      }
+      var lines = input.split("\n");
+      if (lines[lines.length - 1] === "") lines.pop();
+      var groups = [];
+      for (var k = 0; k < lines.length; k++) {
+        if (groups.length > 0 && groups[groups.length - 1].l === lines[k]) groups[groups.length - 1].c++;
+        else groups.push({ l: lines[k], c: 1 });
+      }
+      for (var m = 0; m < groups.length; m++) {
+        if (dupsOnly && groups[m].c < 2) continue;
+        if (countP) process.stdout.write(groups[m].c + " " + groups[m].l + "\n");
+        else process.stdout.write(groups[m].l + "\n");
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/cut.js
+var require_cut = __commonJS({
+  "projects/@machina.at/shell/src/commands/cut.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function cut2(args, ctx) {
+      var delim = "	", fields = "", files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-d" && args[i + 1]) delim = args[++i];
+        else if (args[i] === "-f" && args[i + 1]) fields = args[++i];
+        else if (args[i].startsWith("-d")) delim = args[i].slice(2);
+        else if (args[i].startsWith("-f")) fields = args[i].slice(2);
+        else if (!args[i].startsWith("-")) files.push(args[i]);
+      }
+      if (!fields) {
+        process.stderr.write("cut: missing field list\n");
+        return 1;
+      }
+      var input = files.length === 0 ? ctx.stdin || "" : "";
+      for (var j = 0; j < files.length; j++) {
+        var p = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          input += ctx.fs.readFileSync(p);
+        } catch (e) {
+          process.stderr.write(files[j] + ": " + e.message + "\n");
+          return 1;
+        }
+      }
+      var fns = fields.split(",").map(function(f) {
+        return parseInt(f, 10) - 1;
+      });
+      var lines = input.split("\n");
+      if (lines[lines.length - 1] === "") lines.pop();
+      for (var k = 0; k < lines.length; k++) {
+        var parts = lines[k].split(delim);
+        process.stdout.write(fns.map(function(f) {
+          return parts[f] || "";
+        }).join(delim) + "\n");
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/tr.js
+var require_tr = __commonJS({
+  "projects/@machina.at/shell/src/commands/tr.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function tr2(args, ctx) {
+      var del = false, sets = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-d") del = true;
+        else sets.push(args[i]);
+      }
+      if (sets.length < 1) {
+        process.stderr.write("tr: missing operand\n");
+        return 1;
+      }
+      var input = ctx.stdin || "";
+      if (del) {
+        var result = input;
+        for (var j = 0; j < sets[0].length; j++) result = result.split(sets[0][j]).join("");
+        process.stdout.write(result);
+        return 0;
+      }
+      if (sets.length < 2) {
+        process.stderr.write("tr: missing operand after '" + sets[0] + "'\n");
+        return 1;
+      }
+      var out = "";
+      for (var k = 0; k < input.length; k++) {
+        var idx = sets[0].indexOf(input[k]);
+        out += idx >= 0 ? sets[1][Math.min(idx, sets[1].length - 1)] || input[k] : input[k];
+      }
+      process.stdout.write(out);
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/tee.js
+var require_tee = __commonJS({
+  "projects/@machina.at/shell/src/commands/tee.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function tee2(args, ctx) {
+      var append = false, files = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-a") append = true;
+        else if (!args[i].startsWith("-")) files.push(args[i]);
+      }
+      var input = ctx.stdin || "";
+      process.stdout.write(input);
+      for (var j = 0; j < files.length; j++) {
+        var p = files[j].startsWith("/") ? files[j] : ctx.path.join(ctx.cwd, files[j]);
+        try {
+          if (append) ctx.fs.appendFileSync(p, input);
+          else ctx.fs.writeFileSync(p, input);
+        } catch (e) {
+          process.stderr.write("tee: " + files[j] + ": " + e.message + "\n");
+          return 1;
+        }
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/printf.js
+var require_printf = __commonJS({
+  "projects/@machina.at/shell/src/commands/printf.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function printf(args, ctx) {
+      if (args.length === 0) return 0;
+      var format = args[0], params = args.slice(1), pi = 0;
+      var result = "", i = 0;
+      while (i < format.length) {
+        if (format[i] === "\\") {
+          i++;
+          if (i >= format.length) break;
+          if (format[i] === "n") result += "\n";
+          else if (format[i] === "t") result += "	";
+          else if (format[i] === "r") result += "\r";
+          else if (format[i] === "\\") result += "\\";
+          else if (format[i] === '"') result += '"';
+          else if (format[i] === "'") result += "'";
+          else if (format[i] === "0") result += "\0";
+          else if (format[i] === "a") result += "\x07";
+          else if (format[i] === "b") result += "\b";
+          else if (format[i] === "e") result += "\x1B";
+          else if (format[i] === "f") result += "\f";
+          else if (format[i] === "v") result += "\v";
+          else if (format[i] === "x") {
+            if (i + 1 < format.length && /[0-9a-fA-F]/.test(format[i + 1])) {
+              var hexEnd = i + 2;
+              if (hexEnd < format.length && /[0-9a-fA-F]/.test(format[hexEnd])) hexEnd++;
+              var hex = format.substring(i + 1, hexEnd);
+              result += String.fromCharCode(parseInt(hex, 16));
+              i = hexEnd - 1;
+            } else result += "x";
+          } else result += "\\" + format[i];
+        } else if (format[i] === "%") {
+          i++;
+          if (i >= format.length) break;
+          if (format[i] === "s") result += params[pi++] || "";
+          else if (format[i] === "d") result += parseInt(params[pi++] || "0", 10).toString();
+          else if (format[i] === "%") result += "%";
+          else result += "%" + format[i];
+        } else {
+          result += format[i];
+        }
+        i++;
+      }
+      process.stdout.write(result);
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/find.js
+var require_find = __commonJS({
+  "projects/@machina.at/shell/src/commands/find.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function find2(args, ctx) {
+      var searchPath = ".", namePattern = "", typeFilter = "";
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-name" && args[i + 1]) namePattern = args[++i];
+        else if (args[i] === "-type" && args[i + 1]) typeFilter = args[++i];
+        else if (!args[i].startsWith("-")) searchPath = args[i];
+      }
+      var root = searchPath.startsWith("/") ? searchPath : ctx.path.join(ctx.cwd, searchPath);
+      try {
+        walk(root, namePattern, typeFilter, ctx);
+        return 0;
+      } catch (err2) {
+        process.stderr.write("find: " + searchPath + ": " + err2.message + "\n");
+        return 1;
+      }
+    };
+    function walk(dir, namePattern, typeFilter, ctx) {
+      var entries = ctx.fs.readdirSync(dir);
+      for (var i = 0; i < entries.length; i++) {
+        var full = ctx.path.join(dir, entries[i]);
+        var stat;
+        try {
+          stat = ctx.fs.statSync(full);
+        } catch (_) {
+          continue;
+        }
+        var isDir = stat.isDirectory();
+        if (typeFilter === "f" && isDir) {
+        } else if (typeFilter === "d" && !isDir) {
+        } else if (!namePattern || matchGlob2(entries[i], namePattern)) {
+          process.stdout.write(full + "\n");
+        }
+        if (isDir) walk(full, namePattern, typeFilter, ctx);
+      }
+    }
+    function matchGlob2(name, pattern) {
+      var re = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+      return new RegExp("^" + re + "$").test(name);
+    }
+  }
+});
+
+// projects/@machina.at/shell/src/commands/xargs.js
+var require_xargs = __commonJS({
+  "projects/@machina.at/shell/src/commands/xargs.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function xargs2(args, ctx) {
+      var cmdParts = [];
+      for (var i = 0; i < args.length; i++) {
+        if (!args[i].startsWith("-")) cmdParts.push(args[i]);
+      }
+      var cmdName = cmdParts.length > 0 ? cmdParts.join(" ") : "echo";
+      var input = ctx.stdin || "";
+      var items = input.trim().split(/\s+/).filter(Boolean);
+      if (items.length === 0) return 0;
+      process.stdout.write(cmdName + " " + items.join(" ") + "\n");
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/sleep.js
+var require_sleep = __commonJS({
+  "projects/@machina.at/shell/src/commands/sleep.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function sleep2(args) {
+      if (args.length === 0) {
+        process.stderr.write("sleep: missing operand\n");
+        return 1;
+      }
+      var seconds = parseFloat(args[0]);
+      if (isNaN(seconds) || seconds < 0) {
+        process.stderr.write("sleep: invalid time interval '" + args[0] + "'\n");
+        return 1;
+      }
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/date.js
+var require_date = __commonJS({
+  "projects/@machina.at/shell/src/commands/date.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function date2(args) {
+      var now = /* @__PURE__ */ new Date();
+      if (args.length === 0 || !args[0].startsWith("+")) {
+        process.stdout.write(now.toString() + "\n");
+        return 0;
+      }
+      var fmt = args[0].substring(1);
+      var result = fmt.replace(/%Y/g, now.getFullYear().toString()).replace(/%m/g, String(now.getMonth() + 1).padStart(2, "0")).replace(/%d/g, String(now.getDate()).padStart(2, "0")).replace(/%H/g, String(now.getHours()).padStart(2, "0")).replace(/%M/g, String(now.getMinutes()).padStart(2, "0")).replace(/%S/g, String(now.getSeconds()).padStart(2, "0")).replace(/%%/g, "%");
+      process.stdout.write(result + "\n");
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/basename.js
+var require_basename = __commonJS({
+  "projects/@machina.at/shell/src/commands/basename.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function basename2(args, ctx) {
+      if (args.length === 0) {
+        process.stderr.write("basename: missing operand\n");
+        return 1;
+      }
+      var name = ctx.path.basename(args[0]);
+      if (args[1] && name.endsWith(args[1])) name = name.slice(0, -args[1].length);
+      process.stdout.write(name + "\n");
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/dirname.js
+var require_dirname = __commonJS({
+  "projects/@machina.at/shell/src/commands/dirname.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function dirname2(args, ctx) {
+      if (args.length === 0) {
+        process.stderr.write("dirname: missing operand\n");
+        return 1;
+      }
+      process.stdout.write(ctx.path.dirname(args[0]) + "\n");
+      return 0;
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/bit.js
+var require_bit = __commonJS({
+  "projects/@machina.at/shell/src/commands/bit.js"(exports2, module2) {
+    "use strict";
+    var _bit = null;
+    function getBit() {
+      if (!_bit) {
+        _bit = require("@mizchi/bit");
+      }
+      return _bit;
+    }
+    function createVfsBackend(fs2, pathMod) {
+      return {
+        readFile: function(p) {
+          var data = fs2.readFileSync(p);
+          if (data instanceof Uint8Array) return data;
+          if (data && data.buffer) return new Uint8Array(data.buffer);
+          return new Uint8Array(data);
+        },
+        writeFile: function(p, data) {
+          var dir = pathMod.dirname(p);
+          try {
+            fs2.mkdirSync(dir, { recursive: true });
+          } catch (_e) {
+          }
+          fs2.writeFileSync(p, Buffer.from(data));
+        },
+        readdir: function(p) {
+          try {
+            return fs2.readdirSync(p);
+          } catch (e) {
+            return [];
+          }
+        },
+        isDir: function(p) {
+          try {
+            return fs2.statSync(p).isDirectory();
+          } catch (e) {
+            return false;
+          }
+        },
+        isFile: function(p) {
+          try {
+            return fs2.statSync(p).isFile();
+          } catch (e) {
+            return false;
+          }
+        },
+        mkdirP: function(p) {
+          fs2.mkdirSync(p, { recursive: true });
+        },
+        removeFile: function(p) {
+          try {
+            fs2.unlinkSync(p);
+          } catch (_e) {
+          }
+        },
+        removeDir: function(p) {
+          try {
+            fs2.rmdirSync(p);
+          } catch (_e) {
+          }
+        }
+      };
+    }
+    function handleInit(bit, backend, args, ctx2) {
+      var branchName = "main";
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-b" && args[i + 1]) {
+          branchName = args[++i];
+        }
+      }
+      bit.init(backend, ctx2.cwd, branchName);
+      process.stdout.write("Initialized empty Git repository in " + ctx2.cwd + "/.git/\n");
+      return 0;
+    }
+    function handleAdd(bit, backend, args, ctx2) {
+      if (args.length === 0) {
+        process.stderr.write("usage: bit add <pathspec>...\n");
+        return 1;
+      }
+      var paths = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === ".") {
+          paths.push(".");
+        } else {
+          paths.push(args[i]);
+        }
+      }
+      bit.add(backend, ctx2.cwd, paths);
+      return 0;
+    }
+    function handleCommit(bit, backend, args, ctx2) {
+      var message = "";
+      for (var i = 0; i < args.length; i++) {
+        if ((args[i] === "-m" || args[i] === "--message") && args[i + 1]) {
+          message = args[++i];
+        }
+      }
+      if (!message) {
+        process.stderr.write("error: empty commit message\n");
+        return 1;
+      }
+      var author = ctx2.env && ctx2.env.GIT_AUTHOR_EMAIL || "user@web-kernel";
+      var ts = Math.floor(Date.now() / 1e3);
+      bit.commit(backend, ctx2.cwd, message, author, ts);
+      process.stdout.write("[main] " + message + "\n");
+      return 0;
+    }
+    function handleStatus(bit, backend, args, ctx2) {
+      var result = bit.statusText(backend, ctx2.cwd);
+      if (result) {
+        process.stdout.write(result + "\n");
+      } else {
+        process.stdout.write("nothing to commit, working tree clean\n");
+      }
+      return 0;
+    }
+    function handleLog(bit, backend, args, ctx2) {
+      var maxCount = 20;
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-n" && args[i + 1]) {
+          maxCount = parseInt(args[++i], 10);
+        }
+        if (args[i].match(/^-\d+$/)) {
+          maxCount = parseInt(args[i].slice(1), 10);
+        }
+      }
+      var entries = bit.log(backend, ctx2.cwd, maxCount);
+      if (!entries || entries.length === 0) {
+        process.stderr.write("fatal: no commits yet\n");
+        return 1;
+      }
+      for (var j = 0; j < entries.length; j++) {
+        var e = entries[j];
+        var hash = (e.id || "").substring(0, 7);
+        process.stdout.write(hash + " " + (e.message || "") + "\n");
+      }
+      return 0;
+    }
+    function handleBranch(bit, backend, args, ctx2) {
+      if (args.length === 0) {
+        var branches = bit.branchList(backend, ctx2.cwd);
+        if (branches && branches.length > 0) {
+          for (var i = 0; i < branches.length; i++) {
+            process.stdout.write("  " + branches[i] + "\n");
+          }
+        }
+        return 0;
+      }
+      bit.branchCreate(backend, ctx2.cwd, args[0]);
+      return 0;
+    }
+    function handleCheckout(bit, backend, args, ctx2) {
+      if (args.length === 0) {
+        process.stderr.write("usage: bit checkout <branch>\n");
+        return 1;
+      }
+      bit.checkout(backend, ctx2.cwd, args[0]);
+      process.stdout.write("Switched to branch '" + args[0] + "'\n");
+      return 0;
+    }
+    function handleDiff(bit, backend, args, ctx2) {
+      var result = bit.diffWorktree(backend, ctx2.cwd);
+      if (result) {
+        process.stdout.write(result + "\n");
+      }
+      return 0;
+    }
+    function showHelp() {
+      process.stdout.write(
+        "usage: bit <command> [<args>]\n\ncommands:\n  init       Create an empty Git repository\n  add        Add file contents to the index\n  commit     Record changes to the repository\n  status     Show the working tree status\n  log        Show commit logs\n  branch     List or create branches\n  checkout   Switch branches\n  diff       Show changes in working tree\n"
+      );
+      return 0;
+    }
+    function runBit(args, ctx2) {
+      if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        return showHelp();
+      }
+      if (args[0] === "--version" || args[0] === "-v") {
+        process.stdout.write("bit (web-kernel) using @mizchi/bit JS API\n");
+        return 0;
+      }
+      try {
+        var lib = getBit();
+        var backend = createVfsBackend(ctx2.fs, ctx2.path);
+        var subArgs = args.slice(1);
+        switch (args[0]) {
+          case "init":
+            return handleInit(lib, backend, subArgs, ctx2);
+          case "add":
+            return handleAdd(lib, backend, subArgs, ctx2);
+          case "commit":
+            return handleCommit(lib, backend, subArgs, ctx2);
+          case "status":
+            return handleStatus(lib, backend, subArgs, ctx2);
+          case "log":
+            return handleLog(lib, backend, subArgs, ctx2);
+          case "branch":
+            return handleBranch(lib, backend, subArgs, ctx2);
+          case "checkout":
+            return handleCheckout(lib, backend, subArgs, ctx2);
+          case "diff":
+            return handleDiff(lib, backend, subArgs, ctx2);
+          default:
+            process.stderr.write("bit: '" + args[0] + "' is not a bit command\n");
+            return 1;
+        }
+      } catch (err2) {
+        process.stderr.write("bit: " + (err2.message || err2) + "\n");
+        return 1;
+      }
+    }
+    module2.exports = runBit;
+    if (typeof require !== "undefined" && require.main === module2) {
+      fs = require("fs");
+      path = require("path");
+      cliArgs = process.argv.slice(2);
+      ctx = { cwd: process.cwd(), env: process.env, fs, path };
+      code = runBit(cliArgs, ctx);
+      process.exit(code);
+    }
+    var fs;
+    var path;
+    var cliArgs;
+    var ctx;
+    var code;
+  }
+});
+
+// projects/@machina.at/shell/src/lib/util-commands.ts
+var util_commands_exports = {};
+__export(util_commands_exports, {
+  basename: () => basename,
+  date: () => date,
+  dirname: () => dirname,
+  envCmd: () => envCmd,
+  expr: () => expr,
+  find: () => find,
+  mktemp: () => mktemp,
+  readlink: () => readlink,
+  realpath: () => realpath,
+  seq: () => seq,
+  sleep: () => sleep,
+  uname: () => uname,
+  whoami: () => whoami,
+  xargs: () => xargs,
+  yes: () => yes
+});
+function resolve(p, ctx) {
+  return p.startsWith("/") ? p : ctx.path.join(ctx.cwd, p);
+}
+function find(args, ctx) {
+  let searchPath = ".";
+  let namePattern = "";
+  let typeFilter = "";
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-name" && args[i + 1]) namePattern = args[++i];
+    else if (args[i] === "-type" && args[i + 1]) typeFilter = args[++i];
+    else if (!args[i].startsWith("-")) searchPath = args[i];
+  }
+  const root = resolve(searchPath, ctx);
+  try {
+    walkDir(root, root, namePattern, typeFilter, ctx);
+    return 0;
+  } catch (err2) {
+    ctx.stderr.write("find: " + searchPath + ": " + err2.message + "\n");
+    return 1;
+  }
+}
+function walkDir(root, dir, namePattern, typeFilter, ctx) {
+  const entries = ctx.fs.readdirSync(dir);
+  for (const entry of entries) {
+    const full = ctx.path.join(dir, entry);
+    let stat;
+    try {
+      stat = ctx.fs.statSync(full);
+    } catch {
+      continue;
+    }
+    const isDir = stat.isDirectory();
+    if (typeFilter === "f" && isDir) {
+    } else if (typeFilter === "d" && !isDir) {
+    } else {
+      if (!namePattern || matchGlob(entry, namePattern)) {
+        ctx.stdout.write(full + "\n");
+      }
+    }
+    if (isDir) walkDir(root, full, namePattern, typeFilter, ctx);
+  }
+}
+function matchGlob(name, pattern) {
+  const re = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp("^" + re + "$").test(name);
+}
+function xargs(args, ctx, executeCommand) {
+  const cmdParts = [];
+  for (const arg of args) {
+    if (!arg.startsWith("-")) cmdParts.push(arg);
+  }
+  const cmdName = cmdParts.length > 0 ? cmdParts.join(" ") : "echo";
+  const input = ctx.stdin ?? "";
+  const items = input.trim().split(/\s+/).filter(Boolean);
+  if (items.length === 0) return 0;
+  if (executeCommand) {
+    return executeCommand(cmdName + " " + items.join(" "));
+  }
+  ctx.stdout.write(cmdName + " " + items.join(" ") + "\n");
+  return 0;
+}
+function sleep(args, ctx) {
+  if (args.length === 0) {
+    ctx.stderr.write("sleep: missing operand\n");
+    return 1;
+  }
+  const seconds = parseFloat(args[0]);
+  if (isNaN(seconds) || seconds < 0) {
+    ctx.stderr.write("sleep: invalid time interval '" + args[0] + "'\n");
+    return 1;
+  }
+  return 0;
+}
+function date(args, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  if (args.length === 0) {
+    ctx.stdout.write(now.toString() + "\n");
+    return 0;
+  }
+  if (args[0].startsWith("+")) {
+    const fmt = args[0].substring(1);
+    const result = formatDate(now, fmt);
+    ctx.stdout.write(result + "\n");
+    return 0;
+  }
+  ctx.stdout.write(now.toString() + "\n");
+  return 0;
+}
+function formatDate(d, fmt) {
+  return fmt.replace(/%Y/g, d.getFullYear().toString()).replace(/%m/g, String(d.getMonth() + 1).padStart(2, "0")).replace(/%d/g, String(d.getDate()).padStart(2, "0")).replace(/%H/g, String(d.getHours()).padStart(2, "0")).replace(/%M/g, String(d.getMinutes()).padStart(2, "0")).replace(/%S/g, String(d.getSeconds()).padStart(2, "0")).replace(/%%/g, "%");
+}
+function basename(args, ctx) {
+  if (args.length === 0) {
+    ctx.stderr.write("basename: missing operand\n");
+    return 1;
+  }
+  let name = ctx.path.basename(args[0]);
+  if (args[1] && name.endsWith(args[1])) {
+    name = name.slice(0, -args[1].length);
+  }
+  ctx.stdout.write(name + "\n");
+  return 0;
+}
+function dirname(args, ctx) {
+  if (args.length === 0) {
+    ctx.stderr.write("dirname: missing operand\n");
+    return 1;
+  }
+  ctx.stdout.write(ctx.path.dirname(args[0]) + "\n");
+  return 0;
+}
+function seq(args, ctx) {
+  if (args.length === 0) {
+    ctx.stderr.write("seq: missing operand\n");
+    return 1;
+  }
+  let first = 1, incr = 1, last;
+  if (args.length === 1) {
+    last = parseFloat(args[0]);
+  } else if (args.length === 2) {
+    first = parseFloat(args[0]);
+    last = parseFloat(args[1]);
+  } else {
+    first = parseFloat(args[0]);
+    incr = parseFloat(args[1]);
+    last = parseFloat(args[2]);
+  }
+  if (incr === 0) {
+    ctx.stderr.write("seq: zero increment\n");
+    return 1;
+  }
+  if (incr > 0) {
+    for (let i = first; i <= last; i += incr) ctx.stdout.write(i + "\n");
+  } else {
+    for (let i = first; i >= last; i += incr) ctx.stdout.write(i + "\n");
+  }
+  return 0;
+}
+function readlink(args, ctx) {
+  let followAll = false;
+  const targets = [];
+  for (const arg of args) {
+    if (arg === "-f") followAll = true;
+    else if (!arg.startsWith("-")) targets.push(arg);
+  }
+  if (targets.length === 0) {
+    ctx.stderr.write("readlink: missing operand\n");
+    return 1;
+  }
+  for (const target of targets) {
+    const p = resolve(target, ctx);
+    try {
+      if (followAll && ctx.fs.realpathSync) {
+        ctx.stdout.write(ctx.fs.realpathSync(p) + "\n");
+      } else if (ctx.fs.readlinkSync) {
+        ctx.stdout.write(ctx.fs.readlinkSync(p) + "\n");
+      } else {
+        ctx.stderr.write("readlink: not supported\n");
+        return 1;
+      }
+    } catch (err2) {
+      ctx.stderr.write("readlink: " + target + ": " + err2.message + "\n");
+      return 1;
+    }
+  }
+  return 0;
+}
+function realpath(args, ctx) {
+  const targets = args.filter((a) => !a.startsWith("-"));
+  if (targets.length === 0) {
+    ctx.stderr.write("realpath: missing operand\n");
+    return 1;
+  }
+  for (const target of targets) {
+    const p = resolve(target, ctx);
+    if (ctx.fs.realpathSync) {
+      try {
+        ctx.stdout.write(ctx.fs.realpathSync(p) + "\n");
+      } catch (err2) {
+        ctx.stderr.write("realpath: " + target + ": " + err2.message + "\n");
+        return 1;
+      }
+    } else {
+      ctx.stdout.write(ctx.path.resolve(p) + "\n");
+    }
+  }
+  return 0;
+}
+function mktemp(args, ctx) {
+  let isDir = false;
+  let template = "/tmp/tmp.XXXXXXXXXX";
+  for (const arg of args) {
+    if (arg === "-d") isDir = true;
+    else if (!arg.startsWith("-")) template = arg;
+  }
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const name = template.replace(/X+/g, (match) => {
+    let result = "";
+    for (let i = 0; i < match.length; i++) {
+      result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+  });
+  const p = resolve(name, ctx);
+  try {
+    if (isDir) {
+      ctx.fs.mkdirSync(p);
+    } else {
+      ctx.fs.writeFileSync(p, "");
+    }
+    ctx.stdout.write(p + "\n");
+    return 0;
+  } catch (err2) {
+    ctx.stderr.write("mktemp: " + err2.message + "\n");
+    return 1;
+  }
+}
+function expr(args, ctx) {
+  if (args.length === 0) {
+    ctx.stderr.write("expr: missing operand\n");
+    return 1;
+  }
+  if (args[0] === "length" && args[1]) {
+    ctx.stdout.write(args[1].length + "\n");
+    return args[1].length === 0 ? 1 : 0;
+  }
+  if (args[0] === "substr" && args.length >= 4) {
+    const str = args[1];
+    const pos = parseInt(args[2], 10) - 1;
+    const len = parseInt(args[3], 10);
+    ctx.stdout.write(str.substring(pos, pos + len) + "\n");
+    return 0;
+  }
+  if (args.length === 3) {
+    const [left, op, right] = args;
+    const a = parseInt(left, 10);
+    const b = parseInt(right, 10);
+    if (!isNaN(a) && !isNaN(b)) {
+      let result;
+      switch (op) {
+        case "+":
+          result = a + b;
+          break;
+        case "-":
+          result = a - b;
+          break;
+        case "*":
+          result = a * b;
+          break;
+        case "/":
+          result = b === 0 ? 0 : Math.trunc(a / b);
+          break;
+        case "%":
+          result = b === 0 ? 0 : a % b;
+          break;
+        default:
+          ctx.stderr.write("expr: unknown operator: " + op + "\n");
+          return 2;
+      }
+      ctx.stdout.write(result + "\n");
+      return result === 0 ? 1 : 0;
+    }
+    if (op === ":") {
+      const re = new RegExp("^" + right);
+      const match = left.match(re);
+      if (match) {
+        ctx.stdout.write((match[1] ?? match[0].length) + "\n");
+        return 0;
+      }
+      ctx.stdout.write("0\n");
+      return 1;
+    }
+  }
+  ctx.stdout.write(args.join(" ") + "\n");
+  return 0;
+}
+function yes(args, ctx) {
+  const text = args.length > 0 ? args.join(" ") : "y";
+  const max2 = 1e3;
+  for (let i = 0; i < max2; i++) {
+    ctx.stdout.write(text + "\n");
+  }
+  return 0;
+}
+function whoami(args, ctx) {
+  ctx.stdout.write((ctx.env.USER || ctx.env.LOGNAME || "unknown") + "\n");
+  return 0;
+}
+function uname(args, ctx) {
+  const sysname = ctx.env._UNAME_S || "VFS";
+  const nodename = ctx.env.HOSTNAME || "localhost";
+  const release = ctx.env._UNAME_R || "1.0.0";
+  const machine = ctx.env._UNAME_M || "wasm32";
+  if (args.length === 0 || args.includes("-s")) {
+    ctx.stdout.write(sysname + "\n");
+    return 0;
+  }
+  if (args.includes("-a")) {
+    ctx.stdout.write([sysname, nodename, release, machine].join(" ") + "\n");
+    return 0;
+  }
+  if (args.includes("-n")) {
+    ctx.stdout.write(nodename + "\n");
+    return 0;
+  }
+  if (args.includes("-r")) {
+    ctx.stdout.write(release + "\n");
+    return 0;
+  }
+  if (args.includes("-m")) {
+    ctx.stdout.write(machine + "\n");
+    return 0;
+  }
+  ctx.stdout.write(sysname + "\n");
+  return 0;
+}
+function envCmd(args, ctx) {
+  if (args.length === 0) {
+    for (const [k, v] of Object.entries(ctx.env)) {
+      ctx.stdout.write(k + "=" + v + "\n");
+    }
+    return 0;
+  }
+  for (const arg of args) {
+    const eq = arg.indexOf("=");
+    if (eq !== -1) {
+      ctx.env[arg.substring(0, eq)] = arg.substring(eq + 1);
+    }
+  }
+  return 0;
+}
+var init_util_commands = __esm({
+  "projects/@machina.at/shell/src/lib/util-commands.ts"() {
+    "use strict";
+  }
+});
+
+// projects/@machina.at/shell/src/commands/seq.js
+var require_seq = __commonJS({
+  "projects/@machina.at/shell/src/commands/seq.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_util_commands(), __toCommonJS(util_commands_exports));
+    module2.exports = function seq2(args, ctx) {
+      return lib.seq(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/readlink.js
+var require_readlink = __commonJS({
+  "projects/@machina.at/shell/src/commands/readlink.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_util_commands(), __toCommonJS(util_commands_exports));
+    module2.exports = function readlink2(args, ctx) {
+      return lib.readlink(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/realpath.js
+var require_realpath = __commonJS({
+  "projects/@machina.at/shell/src/commands/realpath.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_util_commands(), __toCommonJS(util_commands_exports));
+    module2.exports = function realpath2(args, ctx) {
+      return lib.realpath(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/mktemp.js
+var require_mktemp = __commonJS({
+  "projects/@machina.at/shell/src/commands/mktemp.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_util_commands(), __toCommonJS(util_commands_exports));
+    module2.exports = function mktemp2(args, ctx) {
+      return lib.mktemp(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/expr.js
+var require_expr = __commonJS({
+  "projects/@machina.at/shell/src/commands/expr.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_util_commands(), __toCommonJS(util_commands_exports));
+    module2.exports = function expr2(args, ctx) {
+      return lib.expr(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/yes.js
+var require_yes = __commonJS({
+  "projects/@machina.at/shell/src/commands/yes.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_util_commands(), __toCommonJS(util_commands_exports));
+    module2.exports = function yes2(args, ctx) {
+      return lib.yes(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/whoami.js
+var require_whoami = __commonJS({
+  "projects/@machina.at/shell/src/commands/whoami.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_util_commands(), __toCommonJS(util_commands_exports));
+    module2.exports = function whoami2(args, ctx) {
+      return lib.whoami(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/uname.js
+var require_uname = __commonJS({
+  "projects/@machina.at/shell/src/commands/uname.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_util_commands(), __toCommonJS(util_commands_exports));
+    module2.exports = function uname2(args, ctx) {
+      return lib.uname(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/lib/file-commands.ts
+var file_commands_exports = {};
+__export(file_commands_exports, {
+  chmod: () => chmod,
+  cp: () => cp,
+  ln: () => ln,
+  mv: () => mv,
+  rm: () => rm,
+  rmdir: () => rmdir,
+  touch: () => touch
+});
+function resolve2(p, ctx) {
+  return p.startsWith("/") ? p : ctx.path.join(ctx.cwd, p);
+}
+function cp(args, ctx) {
+  let recursive = false;
+  const paths = [];
+  for (const arg of args) {
+    if (arg === "-r" || arg === "-R" || arg === "-rf" || arg === "-fr") {
+      recursive = true;
+    } else if (arg === "-f") {
+    } else if (!arg.startsWith("-")) {
+      paths.push(arg);
+    }
+  }
+  if (paths.length < 2) {
+    ctx.stderr.write("cp: missing file operand\n");
+    return 1;
+  }
+  const src = resolve2(paths[0], ctx);
+  const dst = resolve2(paths[1], ctx);
+  try {
+    const stat = ctx.fs.statSync(src);
+    if (stat.isDirectory()) {
+      if (!recursive) {
+        ctx.stderr.write("cp: -r not specified; omitting directory '" + paths[0] + "'\n");
+        return 1;
+      }
+      copyDir(src, dst, ctx);
+    } else {
+      const content = ctx.fs.readFileSync(src);
+      ctx.fs.writeFileSync(dst, content);
+    }
+    return 0;
+  } catch (err2) {
+    ctx.stderr.write("cp: " + paths[0] + ": " + err2.message + "\n");
+    return 1;
+  }
+}
+function copyDir(src, dst, ctx) {
+  try {
+    ctx.fs.mkdirSync(dst);
+  } catch {
+  }
+  const entries = ctx.fs.readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = ctx.path.join(src, entry);
+    const dstPath = ctx.path.join(dst, entry);
+    const stat = ctx.fs.statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDir(srcPath, dstPath, ctx);
+    } else {
+      ctx.fs.writeFileSync(dstPath, ctx.fs.readFileSync(srcPath));
+    }
+  }
+}
+function mv(args, ctx) {
+  const paths = [];
+  for (const arg of args) {
+    if (!arg.startsWith("-")) paths.push(arg);
+  }
+  if (paths.length < 2) {
+    ctx.stderr.write("mv: missing file operand\n");
+    return 1;
+  }
+  const src = resolve2(paths[0], ctx);
+  const dst = resolve2(paths[1], ctx);
+  try {
+    ctx.fs.renameSync(src, dst);
+    return 0;
+  } catch (err2) {
+    ctx.stderr.write("mv: " + paths[0] + ": " + err2.message + "\n");
+    return 1;
+  }
+}
+function rm(args, ctx) {
+  let recursive = false;
+  let force = false;
+  const targets = [];
+  for (const arg of args) {
+    if (arg === "-r" || arg === "-R") recursive = true;
+    else if (arg === "-f") force = true;
+    else if (arg === "-rf" || arg === "-fr") {
+      recursive = true;
+      force = true;
+    } else if (!arg.startsWith("-")) targets.push(arg);
+  }
+  if (targets.length === 0) {
+    if (!force) {
+      ctx.stderr.write("rm: missing operand\n");
+      return 1;
+    }
+    return 0;
+  }
+  for (const target of targets) {
+    const p = resolve2(target, ctx);
+    try {
+      const stat = ctx.fs.statSync(p);
+      if (stat.isDirectory()) {
+        if (!recursive) {
+          ctx.stderr.write("rm: cannot remove '" + target + "': Is a directory\n");
+          return 1;
+        }
+        rmDir(p, ctx);
+      } else {
+        ctx.fs.unlinkSync(p);
+      }
+    } catch (err2) {
+      if (!force) {
+        ctx.stderr.write("rm: " + target + ": " + err2.message + "\n");
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+function rmDir(p, ctx) {
+  const entries = ctx.fs.readdirSync(p);
+  for (const entry of entries) {
+    const full = ctx.path.join(p, entry);
+    const stat = ctx.fs.statSync(full);
+    if (stat.isDirectory()) {
+      rmDir(full, ctx);
+    } else {
+      ctx.fs.unlinkSync(full);
+    }
+  }
+  ctx.fs.rmdirSync(p);
+}
+function rmdir(args, ctx) {
+  if (args.length === 0) {
+    ctx.stderr.write("rmdir: missing operand\n");
+    return 1;
+  }
+  for (const arg of args) {
+    if (arg.startsWith("-")) continue;
+    const p = resolve2(arg, ctx);
+    try {
+      const entries = ctx.fs.readdirSync(p);
+      if (entries.length > 0) {
+        ctx.stderr.write("rmdir: " + arg + ": Directory not empty\n");
+        return 1;
+      }
+      ctx.fs.rmdirSync(p);
+    } catch (err2) {
+      ctx.stderr.write("rmdir: " + arg + ": " + err2.message + "\n");
+      return 1;
+    }
+  }
+  return 0;
+}
+function touch(args, ctx) {
+  if (args.length === 0) {
+    ctx.stderr.write("touch: missing file operand\n");
+    return 1;
+  }
+  for (const arg of args) {
+    if (arg.startsWith("-")) continue;
+    const p = resolve2(arg, ctx);
+    try {
+      if (ctx.fs.existsSync(p)) {
+        ctx.fs.utimesSync(p, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+      } else {
+        ctx.fs.writeFileSync(p, "");
+      }
+    } catch (err2) {
+      ctx.stderr.write("touch: " + arg + ": " + err2.message + "\n");
+      return 1;
+    }
+  }
+  return 0;
+}
+function ln(args, ctx) {
+  let symbolic = false;
+  const paths = [];
+  for (const arg of args) {
+    if (arg === "-s") symbolic = true;
+    else if (!arg.startsWith("-")) paths.push(arg);
+  }
+  if (paths.length < 2) {
+    ctx.stderr.write("ln: missing file operand\n");
+    return 1;
+  }
+  const target = resolve2(paths[0], ctx);
+  const linkName = resolve2(paths[1], ctx);
+  try {
+    if (symbolic) {
+      ctx.fs.symlinkSync(target, linkName);
+    } else {
+      ctx.fs.linkSync(target, linkName);
+    }
+    return 0;
+  } catch (err2) {
+    ctx.stderr.write("ln: " + paths[1] + ": " + err2.message + "\n");
+    return 1;
+  }
+}
+function chmod(args, ctx) {
+  let recursive = false;
+  const rest = [];
+  for (const arg of args) {
+    if (arg === "-R" || arg === "-r") recursive = true;
+    else if (!arg.startsWith("-")) rest.push(arg);
+  }
+  if (rest.length < 2) {
+    ctx.stderr.write("chmod: missing operand\n");
+    return 1;
+  }
+  const modeStr = rest[0];
+  const targets = rest.slice(1);
+  let mode;
+  if (/^\d+$/.test(modeStr)) {
+    mode = parseInt(modeStr, 8);
+  } else {
+    mode = parseSymbolicMode(modeStr);
+    if (mode < 0) {
+      ctx.stderr.write("chmod: invalid mode: " + modeStr + "\n");
+      return 1;
+    }
+  }
+  for (const target of targets) {
+    const p = resolve2(target, ctx);
+    try {
+      if (ctx.fs.chmodSync) {
+        ctx.fs.chmodSync(p, mode);
+      }
+      if (recursive) {
+        try {
+          const stat = ctx.fs.statSync(p);
+          if (stat.isDirectory()) chmodRecursive(p, mode, ctx);
+        } catch {
+        }
+      }
+    } catch (err2) {
+      ctx.stderr.write("chmod: " + target + ": " + err2.message + "\n");
+      return 1;
+    }
+  }
+  return 0;
+}
+function parseSymbolicMode(s) {
+  const match = s.match(/^([+-])([rwx]+)$/);
+  if (!match) return -1;
+  const [, op, perms] = match;
+  let bits2 = 0;
+  if (perms.includes("r")) bits2 |= 292;
+  if (perms.includes("w")) bits2 |= 146;
+  if (perms.includes("x")) bits2 |= 73;
+  return op === "+" ? bits2 : bits2;
+}
+function chmodRecursive(dir, mode, ctx) {
+  const entries = ctx.fs.readdirSync(dir);
+  for (const entry of entries) {
+    const full = ctx.path.join(dir, entry);
+    if (ctx.fs.chmodSync) ctx.fs.chmodSync(full, mode);
+    try {
+      const stat = ctx.fs.statSync(full);
+      if (stat.isDirectory()) chmodRecursive(full, mode, ctx);
+    } catch {
+    }
+  }
+}
+var init_file_commands = __esm({
+  "projects/@machina.at/shell/src/lib/file-commands.ts"() {
+    "use strict";
+  }
+});
+
+// projects/@machina.at/shell/src/commands/chmod.js
+var require_chmod = __commonJS({
+  "projects/@machina.at/shell/src/commands/chmod.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_file_commands(), __toCommonJS(file_commands_exports));
+    module2.exports = function chmod2(args, ctx) {
+      return lib.chmod(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/lib/text-commands.ts
+var text_commands_exports = {};
+__export(text_commands_exports, {
+  cat: () => cat,
+  cut: () => cut,
+  grep: () => grep,
+  head: () => head,
+  nl: () => nl,
+  paste: () => paste,
+  rev: () => rev,
+  sed: () => sed,
+  sort: () => sort,
+  tail: () => tail,
+  tee: () => tee,
+  tr: () => tr,
+  uniq: () => uniq,
+  wc: () => wc
+});
+function resolve3(p, ctx) {
+  return p.startsWith("/") ? p : ctx.path.join(ctx.cwd, p);
+}
+function parseRangeList(spec) {
+  const indices = [];
+  for (const part of spec.split(",")) {
+    if (part.includes("-")) {
+      const [s, e] = part.split("-").map((n) => parseInt(n, 10) - 1);
+      for (let i = s; i <= (isNaN(e) ? s : e); i++) indices.push(i);
+    } else {
+      indices.push(parseInt(part, 10) - 1);
+    }
+  }
+  return indices;
+}
+function expandTrClass(s) {
+  return s.replace(/\[:upper:]/g, "ABCDEFGHIJKLMNOPQRSTUVWXYZ").replace(/\[:lower:]/g, "abcdefghijklmnopqrstuvwxyz").replace(/\[:digit:]/g, "0123456789").replace(/\[:alpha:]/g, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").replace(/\[:space:]/g, " 	\n\r\v\f");
+}
+function readInput(files, ctx) {
+  if (files.length === 0) return ctx.stdin ?? null;
+  let result = "";
+  for (const f of files) {
+    const p = resolve3(f, ctx);
+    try {
+      const c = ctx.fs.readFileSync(p);
+      result += typeof c === "string" ? c : new TextDecoder().decode(c);
+    } catch (err2) {
+      ctx.stderr.write(f + ": " + err2.message + "\n");
+      return null;
+    }
+  }
+  return result;
+}
+function grep(args, ctx) {
+  let invert = false, ignoreCase = false, countOnly = false, lineNum = false;
+  let extended = false, fileNameOnly = false, wordMatch = false;
+  let pattern = "";
+  const files = [];
+  let patternSet = false;
+  for (const arg of args) {
+    if (arg === "-v") invert = true;
+    else if (arg === "-i") ignoreCase = true;
+    else if (arg === "-c") countOnly = true;
+    else if (arg === "-n") lineNum = true;
+    else if (arg === "-E") extended = true;
+    else if (arg === "-l") fileNameOnly = true;
+    else if (arg === "-w") wordMatch = true;
+    else if (arg.startsWith("-")) {
+    } else if (!patternSet) {
+      pattern = arg;
+      patternSet = true;
+    } else files.push(arg);
+  }
+  if (!patternSet) {
+    ctx.stderr.write("grep: missing pattern\n");
+    return 2;
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  let flags = ignoreCase ? "i" : "";
+  if (extended) flags += "";
+  const pat = wordMatch ? "\\b" + pattern + "\\b" : pattern;
+  const re = new RegExp(pat, flags);
+  const lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  let count = 0;
+  const matched = [];
+  for (let i = 0; i < lines.length; i++) {
+    const match = re.test(lines[i]);
+    if (match !== invert) {
+      count++;
+      if (lineNum) matched.push(i + 1 + ":" + lines[i]);
+      else matched.push(lines[i]);
+    }
+  }
+  if (fileNameOnly) {
+    if (count > 0 && files.length > 0) ctx.stdout.write(files.join("\n") + "\n");
+    return count > 0 ? 0 : 1;
+  }
+  if (countOnly) {
+    ctx.stdout.write(count + "\n");
+  } else {
+    for (const m of matched) ctx.stdout.write(m + "\n");
+  }
+  return count > 0 ? 0 : 1;
+}
+function sed(args, ctx) {
+  const files = [];
+  let expression = "";
+  let silent = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-n") silent = true;
+    else if (args[i] === "-e" && args[i + 1]) expression = args[++i];
+    else if (!args[i].startsWith("-") && !expression) expression = args[i];
+    else if (!args[i].startsWith("-")) files.push(args[i]);
+  }
+  if (!expression) {
+    ctx.stderr.write("sed: missing expression\n");
+    return 1;
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  const lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const addrMatch = expression.match(/^(\d+)?(?:,(\d+))?(.*)/);
+  if (!addrMatch) {
+    ctx.stderr.write("sed: invalid expression\n");
+    return 1;
+  }
+  const addrStart = addrMatch[1] ? parseInt(addrMatch[1], 10) : 0;
+  const addrEnd = addrMatch[2] ? parseInt(addrMatch[2], 10) : 0;
+  const cmd = addrMatch[3];
+  const patCmd = expression.match(/^\/(.+?)\/([dp])$/);
+  if (patCmd) {
+    const re2 = new RegExp(patCmd[1]);
+    const action = patCmd[2];
+    for (let i = 0; i < lines.length; i++) {
+      const matches = re2.test(lines[i]);
+      if (action === "d") {
+        if (!matches && !silent) ctx.stdout.write(lines[i] + "\n");
+      } else if (action === "p") {
+        if (!silent && !matches) ctx.stdout.write(lines[i] + "\n");
+        if (matches) ctx.stdout.write(lines[i] + "\n");
+      }
+    }
+    return 0;
+  }
+  if (cmd === "d") {
+    for (let i = 0; i < lines.length; i++) {
+      const lineNum = i + 1;
+      const inRange = addrEnd ? lineNum >= addrStart && lineNum <= addrEnd : lineNum === addrStart;
+      if (!inRange) ctx.stdout.write(lines[i] + "\n");
+    }
+    return 0;
+  }
+  if (cmd === "p") {
+    for (let i = 0; i < lines.length; i++) {
+      const lineNum = i + 1;
+      const inRange = addrEnd ? lineNum >= addrStart && lineNum <= addrEnd : lineNum === addrStart;
+      if (!silent) ctx.stdout.write(lines[i] + "\n");
+      if (inRange) ctx.stdout.write(lines[i] + "\n");
+    }
+    return 0;
+  }
+  const sMatch = cmd.match(/^s(.)(.+?)\1(.*?)\1([g]?)$/);
+  if (!sMatch) {
+    ctx.stderr.write("sed: invalid expression: " + expression + "\n");
+    return 1;
+  }
+  const [, , pat, repl, flag] = sMatch;
+  const re = new RegExp(pat, flag === "g" ? "g" : "");
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const inRange = addrStart ? addrEnd ? lineNum >= addrStart && lineNum <= addrEnd : lineNum === addrStart : true;
+    const replaced = inRange ? lines[i].replace(re, repl) : lines[i];
+    if (!silent) ctx.stdout.write(replaced + "\n");
+  }
+  return 0;
+}
+function wc(args, ctx) {
+  let linesOnly = false, wordsOnly = false, charsOnly = false;
+  const files = [];
+  for (const arg of args) {
+    if (arg === "-l") linesOnly = true;
+    else if (arg === "-w") wordsOnly = true;
+    else if (arg === "-c" || arg === "-m") charsOnly = true;
+    else if (!arg.startsWith("-")) files.push(arg);
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  const lineCount = input.split("\n").length - (input.endsWith("\n") ? 1 : 0);
+  const wordCount = input.trim() ? input.trim().split(/\s+/).length : 0;
+  const charCount = input.length;
+  if (linesOnly) ctx.stdout.write(lineCount + "\n");
+  else if (wordsOnly) ctx.stdout.write(wordCount + "\n");
+  else if (charsOnly) ctx.stdout.write(charCount + "\n");
+  else ctx.stdout.write(lineCount + " " + wordCount + " " + charCount + "\n");
+  return 0;
+}
+function sort(args, ctx) {
+  let reverse = false, numeric = false, unique = false;
+  let keyField = 0, separator = "";
+  const files = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-r") reverse = true;
+    else if (args[i] === "-n") numeric = true;
+    else if (args[i] === "-u") unique = true;
+    else if (args[i] === "-k" && args[i + 1]) keyField = parseInt(args[++i], 10);
+    else if (args[i] === "-t" && args[i + 1]) separator = args[++i];
+    else if (!args[i].startsWith("-")) files.push(args[i]);
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  let lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const getKey = (line) => {
+    if (keyField > 0) {
+      const sep = separator || /\s+/;
+      const parts = typeof sep === "string" ? line.split(sep) : line.split(sep);
+      return parts[keyField - 1] ?? "";
+    }
+    return line;
+  };
+  if (numeric) {
+    lines.sort((a, b) => parseFloat(getKey(a)) - parseFloat(getKey(b)));
+  } else {
+    lines.sort((a, b) => getKey(a).localeCompare(getKey(b)));
+  }
+  if (reverse) lines.reverse();
+  if (unique) lines = [...new Set(lines)];
+  for (const l of lines) ctx.stdout.write(l + "\n");
+  return 0;
+}
+function uniq(args, ctx) {
+  let countPrefix = false, dupsOnly = false;
+  const files = [];
+  for (const arg of args) {
+    if (arg === "-c") countPrefix = true;
+    else if (arg === "-d") dupsOnly = true;
+    else if (!arg.startsWith("-")) files.push(arg);
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  const lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const groups = [];
+  for (const line of lines) {
+    if (groups.length > 0 && groups[groups.length - 1].line === line) {
+      groups[groups.length - 1].count++;
+    } else {
+      groups.push({ line, count: 1 });
+    }
+  }
+  for (const g of groups) {
+    if (dupsOnly && g.count < 2) continue;
+    if (countPrefix) ctx.stdout.write(g.count + " " + g.line + "\n");
+    else ctx.stdout.write(g.line + "\n");
+  }
+  return 0;
+}
+function cut(args, ctx) {
+  let delimiter = "	";
+  let fields = "";
+  let charMode = "";
+  const files = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-d" && args[i + 1]) delimiter = args[++i];
+    else if (args[i] === "-f" && args[i + 1]) fields = args[++i];
+    else if (args[i] === "-c" && args[i + 1]) charMode = args[++i];
+    else if (args[i].startsWith("-d")) delimiter = args[i].slice(2);
+    else if (args[i].startsWith("-f")) fields = args[i].slice(2);
+    else if (args[i].startsWith("-c")) charMode = args[i].slice(2);
+    else if (!args[i].startsWith("-")) files.push(args[i]);
+  }
+  if (!fields && !charMode) {
+    ctx.stderr.write("cut: missing field or character list\n");
+    return 1;
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  const lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  if (charMode) {
+    const indices = parseRangeList(charMode);
+    for (const line of lines) {
+      ctx.stdout.write(indices.map((i) => line[i] ?? "").join("") + "\n");
+    }
+    return 0;
+  }
+  const fieldNums = parseRangeList(fields);
+  for (const line of lines) {
+    const parts = line.split(delimiter);
+    const selected = fieldNums.map((f) => parts[f] ?? "").join(delimiter);
+    ctx.stdout.write(selected + "\n");
+  }
+  return 0;
+}
+function tr(args, ctx) {
+  let deleteMode = false;
+  const sets = [];
+  for (const arg of args) {
+    if (arg === "-d") deleteMode = true;
+    else sets.push(arg);
+  }
+  if (sets.length < 1) {
+    ctx.stderr.write("tr: missing operand\n");
+    return 1;
+  }
+  const input = ctx.stdin ?? "";
+  const set1 = expandTrClass(sets[0]);
+  if (deleteMode) {
+    let result2 = input;
+    for (const ch of set1) result2 = result2.split(ch).join("");
+    ctx.stdout.write(result2);
+    return 0;
+  }
+  if (sets.length < 2) {
+    ctx.stderr.write("tr: missing operand after '" + sets[0] + "'\n");
+    return 1;
+  }
+  const set2 = expandTrClass(sets[1]);
+  let result = "";
+  for (const ch of input) {
+    const idx = set1.indexOf(ch);
+    result += idx >= 0 ? set2[Math.min(idx, set2.length - 1)] ?? ch : ch;
+  }
+  ctx.stdout.write(result);
+  return 0;
+}
+function head(args, ctx) {
+  let count = 10;
+  const files = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-n" && args[i + 1]) {
+      count = parseInt(args[++i], 10);
+    } else if (/^-\d+$/.test(args[i])) {
+      count = parseInt(args[i].slice(1), 10);
+    } else if (!args[i].startsWith("-")) files.push(args[i]);
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  const lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const selected = lines.slice(0, count);
+  for (const l of selected) ctx.stdout.write(l + "\n");
+  return 0;
+}
+function tail(args, ctx) {
+  let count = 10;
+  const files = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-n" && args[i + 1]) {
+      count = parseInt(args[++i], 10);
+    } else if (/^-\d+$/.test(args[i])) {
+      count = parseInt(args[i].slice(1), 10);
+    } else if (!args[i].startsWith("-")) files.push(args[i]);
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  const lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const selected = lines.slice(-count);
+  for (const l of selected) ctx.stdout.write(l + "\n");
+  return 0;
+}
+function tee(args, ctx) {
+  let append = false;
+  const files = [];
+  for (const arg of args) {
+    if (arg === "-a") append = true;
+    else if (!arg.startsWith("-")) files.push(arg);
+  }
+  const input = ctx.stdin ?? "";
+  ctx.stdout.write(input);
+  for (const f of files) {
+    const p = resolve3(f, ctx);
+    try {
+      if (append) ctx.fs.appendFileSync(p, input);
+      else ctx.fs.writeFileSync(p, input);
+    } catch (err2) {
+      ctx.stderr.write("tee: " + f + ": " + err2.message + "\n");
+      return 1;
+    }
+  }
+  return 0;
+}
+function rev(args, ctx) {
+  const files = args.filter((a) => !a.startsWith("-"));
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  const lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  for (const l of lines) ctx.stdout.write([...l].reverse().join("") + "\n");
+  return 0;
+}
+function paste(args, ctx) {
+  let delimiter = "	";
+  const files = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-d" && args[i + 1]) delimiter = args[++i];
+    else if (!args[i].startsWith("-")) files.push(args[i]);
+  }
+  if (files.length === 0) {
+    const input = ctx.stdin ?? "";
+    const lines = input.split("\n");
+    if (lines[lines.length - 1] === "") lines.pop();
+    ctx.stdout.write(lines.join(delimiter) + "\n");
+    return 0;
+  }
+  const allLines = [];
+  let maxLines = 0;
+  for (const f of files) {
+    const p = resolve3(f, ctx);
+    try {
+      const c = ctx.fs.readFileSync(p);
+      const content = typeof c === "string" ? c : new TextDecoder().decode(c);
+      const lines = content.split("\n");
+      if (lines[lines.length - 1] === "") lines.pop();
+      allLines.push(lines);
+      maxLines = Math.max(maxLines, lines.length);
+    } catch (err2) {
+      ctx.stderr.write("paste: " + f + ": " + err2.message + "\n");
+      return 1;
+    }
+  }
+  for (let i = 0; i < maxLines; i++) {
+    const parts = allLines.map((lines) => lines[i] ?? "");
+    ctx.stdout.write(parts.join(delimiter) + "\n");
+  }
+  return 0;
+}
+function nl(args, ctx) {
+  let numberAll = false;
+  const files = [];
+  for (const arg of args) {
+    if (arg === "-ba") numberAll = true;
+    else if (!arg.startsWith("-")) files.push(arg);
+  }
+  const input = readInput(files, ctx);
+  if (input === null) return 1;
+  const lines = input.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  let num = 1;
+  for (const l of lines) {
+    if (!numberAll && l.trim() === "") {
+      ctx.stdout.write("       " + l + "\n");
+    } else {
+      ctx.stdout.write(String(num).padStart(6, " ") + "	" + l + "\n");
+      num++;
+    }
+  }
+  return 0;
+}
+function cat(args, ctx) {
+  let showLineNums = false;
+  const files = [];
+  for (const arg of args) {
+    if (arg === "-n") showLineNums = true;
+    else if (!arg.startsWith("-")) files.push(arg);
+  }
+  if (files.length === 0) {
+    const input = ctx.stdin ?? "";
+    if (showLineNums) {
+      const lines = input.split("\n");
+      if (lines[lines.length - 1] === "") lines.pop();
+      for (let i = 0; i < lines.length; i++) {
+        ctx.stdout.write(String(i + 1).padStart(6, " ") + "	" + lines[i] + "\n");
+      }
+    } else {
+      ctx.stdout.write(input);
+    }
+    return 0;
+  }
+  let lineNum = 1;
+  for (const f of files) {
+    const p = resolve3(f, ctx);
+    try {
+      const c = ctx.fs.readFileSync(p);
+      const content = typeof c === "string" ? c : new TextDecoder().decode(c);
+      if (showLineNums) {
+        const lines = content.split("\n");
+        if (lines[lines.length - 1] === "") lines.pop();
+        for (const l of lines) {
+          ctx.stdout.write(String(lineNum++).padStart(6, " ") + "	" + l + "\n");
+        }
+      } else {
+        ctx.stdout.write(content);
+      }
+    } catch (err2) {
+      ctx.stderr.write("cat: " + f + ": " + err2.message + "\n");
+      return 1;
+    }
+  }
+  return 0;
+}
+var init_text_commands = __esm({
+  "projects/@machina.at/shell/src/lib/text-commands.ts"() {
+    "use strict";
+  }
+});
+
+// projects/@machina.at/shell/src/commands/nl.js
+var require_nl = __commonJS({
+  "projects/@machina.at/shell/src/commands/nl.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_text_commands(), __toCommonJS(text_commands_exports));
+    module2.exports = function nl2(args, ctx) {
+      return lib.nl(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/paste.js
+var require_paste = __commonJS({
+  "projects/@machina.at/shell/src/commands/paste.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_text_commands(), __toCommonJS(text_commands_exports));
+    module2.exports = function paste2(args, ctx) {
+      return lib.paste(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/rev.js
+var require_rev = __commonJS({
+  "projects/@machina.at/shell/src/commands/rev.js"(exports2, module2) {
+    "use strict";
+    var lib = (init_text_commands(), __toCommonJS(text_commands_exports));
+    module2.exports = function rev3(args, ctx) {
+      return lib.rev(args, { ...ctx, stdout: process.stdout, stderr: process.stderr });
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/lib/net-commands.ts
+var net_commands_exports = {};
+__export(net_commands_exports, {
+  curl: () => curl
+});
+function base64ToBytes(b64) {
+  if (typeof atob === "function") {
+    const bin = atob(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  return new Uint8Array(globalThis.Buffer.from(b64, "base64"));
+}
+function parseArgs(args) {
+  const opts = {
+    url: null,
+    method: null,
+    headers: {},
+    body: null,
+    outputFile: null,
+    includeHeaders: false,
+    followRedirects: false,
+    silent: false,
+    failOnError: false
+  };
+  let i = 0;
+  let endOfOptions = false;
+  while (i < args.length) {
+    const a = args[i];
+    if (!endOfOptions && a === "--") {
+      endOfOptions = true;
+      i++;
+      continue;
+    }
+    if (!endOfOptions && a.startsWith("-") && a.length > 1) {
+      switch (a) {
+        case "-X":
+          if (!args[i + 1]) return { opts, error: `option '${a}' requires an argument` };
+          opts.method = args[++i];
+          break;
+        case "-H": {
+          if (!args[i + 1]) return { opts, error: `option '${a}' requires an argument` };
+          const h = args[++i];
+          const idx = h.indexOf(":");
+          if (idx < 0) return { opts, error: `invalid header '${h}'` };
+          const k = h.slice(0, idx).trim();
+          const v = h.slice(idx + 1).trim();
+          opts.headers[k] = v;
+          break;
+        }
+        case "-d":
+        case "--data":
+          if (args[i + 1] === void 0) return { opts, error: `option '${a}' requires an argument` };
+          opts.body = args[++i];
+          break;
+        case "-o":
+          if (!args[i + 1]) return { opts, error: `option '${a}' requires an argument` };
+          opts.outputFile = args[++i];
+          break;
+        case "-i":
+          opts.includeHeaders = true;
+          break;
+        case "-L":
+          opts.followRedirects = true;
+          break;
+        case "-s":
+        case "--silent":
+          opts.silent = true;
+          break;
+        case "-f":
+        case "--fail":
+          opts.failOnError = true;
+          break;
+        default:
+          return { opts, error: `option '${a}' unknown` };
+      }
+      i++;
+    } else {
+      if (opts.url !== null) return { opts, error: `unexpected argument '${a}'` };
+      opts.url = a;
+      i++;
+    }
+  }
+  return { opts };
+}
+function resolveSyncRequest(ctx) {
+  if (ctx.syncRequest) return ctx.syncRequest;
+  const g = globalThis.syncFetch;
+  if (typeof g === "function") return g;
+  return childProcessSyncRequest;
+}
+function resolveOutputPath(p, ctx) {
+  return p.startsWith("/") ? p : ctx.path.join(ctx.cwd, p);
+}
+function formatHeaderBlock(res) {
+  let out = `HTTP/1.1 ${res.status} ${res.statusText}\r
+`;
+  for (const k of Object.keys(res.headers)) {
+    out += `${k}: ${res.headers[k]}\r
+`;
+  }
+  out += "\r\n";
+  return out;
+}
+function curl(args, ctx) {
+  const stdout = ctx.stdout ?? process.stdout;
+  const stderr = ctx.stderr ?? process.stderr;
+  const parsed = parseArgs(args);
+  if (parsed.error) {
+    if (!parsed.opts.silent) stderr.write(`curl: ${parsed.error}
+`);
+    return 2;
+  }
+  const opts = parsed.opts;
+  if (!opts.url) {
+    if (!opts.silent) stderr.write("curl: no URL specified\n");
+    return 2;
+  }
+  const sr = resolveSyncRequest(ctx);
+  if (!sr) {
+    if (!opts.silent) stderr.write("curl: syncRequest transport unavailable\n");
+    return 2;
+  }
+  const method = opts.method ?? (opts.body !== null ? "POST" : "GET");
+  let currentUrl = opts.url;
+  let res = { status: 0, statusText: "", headers: {}, body: "" };
+  let redirects = 0;
+  let done = false;
+  try {
+    while (!done) {
+      res = sr(currentUrl, {
+        method,
+        headers: opts.headers,
+        body: opts.body ?? void 0
+      });
+      if (opts.followRedirects && res.status >= 300 && res.status < 400) {
+        const loc = res.headers["location"] ?? res.headers["Location"];
+        if (!loc) {
+          done = true;
+          break;
+        }
+        redirects++;
+        if (redirects > MAX_REDIRECTS) {
+          if (!opts.silent) {
+            stderr.write(`curl: maximum redirect (${MAX_REDIRECTS}) reached
+`);
+          }
+          return 47;
+        }
+        currentUrl = loc;
+        continue;
+      }
+      done = true;
+    }
+  } catch (err2) {
+    if (!opts.silent) stderr.write(`curl: ${err2.message ?? String(err2)}
+`);
+    return 7;
+  }
+  if (opts.failOnError && res.status >= 400) {
+    if (!opts.silent) {
+      stderr.write(`curl: HTTP ${res.status} ${res.statusText}
+`);
+    }
+    return 22;
+  }
+  const headerBlock = opts.includeHeaders ? formatHeaderBlock(res) : "";
+  if (opts.outputFile) {
+    const filePath = resolveOutputPath(opts.outputFile, ctx);
+    try {
+      if (res.isBinary) {
+        ctx.fs.writeFileSync(filePath, base64ToBytes(res.body));
+      } else {
+        ctx.fs.writeFileSync(filePath, headerBlock + res.body);
+      }
+    } catch (err2) {
+      if (!opts.silent) stderr.write(`curl: ${opts.outputFile}: ${err2.message}
+`);
+      return 23;
+    }
+  } else {
+    if (headerBlock) stdout.write(headerBlock);
+    stdout.write(res.body);
+  }
+  return 0;
+}
+var MAX_REDIRECTS, childProcessSyncRequest;
+var init_net_commands = __esm({
+  "projects/@machina.at/shell/src/lib/net-commands.ts"() {
+    "use strict";
+    MAX_REDIRECTS = 10;
+    childProcessSyncRequest = (url, init) => {
+      let cp2;
+      try {
+        cp2 = typeof require !== "undefined" ? require("child_process") : null;
+      } catch {
+        throw new Error("syncRequest transport unavailable (child_process not loadable)");
+      }
+      if (!cp2) throw new Error("syncRequest transport unavailable (require not available)");
+      const method = init.method ?? "GET";
+      const headers = init.headers ?? {};
+      const body = init.body ?? "";
+      const script = `
+(async () => {
+  try {
+    const res = await fetch(${JSON.stringify(url)}, {
+      method: ${JSON.stringify(method)},
+      headers: ${JSON.stringify(headers)},
+      ${body ? `body: ${JSON.stringify(body)},` : ""}
+    });
+    const h = {};
+    res.headers.forEach((v, k) => { h[k] = v; });
+    // binary content-type \u306F base64 \u5316\u3057\u3066 isBinary:true \u3067\u8FD4\u3059 (curl -o \u304C\u5FA9\u5143\u3059\u308B)
+    var ct = (h['content-type'] || '');
+    var isBinary = /(application\\/octet-stream|application\\/gzip|application\\/x-gzip|application\\/zip|application\\/wasm|application\\/x-tar)/.test(ct);
+    var bodyOut;
+    if (isBinary) {
+      var buf = Buffer.from(await res.arrayBuffer());
+      bodyOut = buf.toString('base64');
+    } else {
+      bodyOut = await res.text();
+    }
+    process.stdout.write(JSON.stringify({ status: res.status, statusText: res.statusText, headers: h, body: bodyOut, isBinary: isBinary }));
+  } catch (e) {
+    process.stderr.write(String(e && e.message ? e.message : e));
+    process.exit(1);
+  }
+})();
+`;
+      const execPath = globalThis.process?.execPath ?? "node";
+      const r = cp2.spawnSync(execPath, ["-e", script], { timeout: 6e4, maxBuffer: 64 * 1024 * 1024 });
+      if (r.status !== 0) {
+        const err2 = typeof r.stderr === "string" ? r.stderr : r.stderr?.toString() ?? "";
+        throw new Error(err2 || `child node exited with status ${r.status}`);
+      }
+      const out = typeof r.stdout === "string" ? r.stdout : r.stdout?.toString() ?? "";
+      return JSON.parse(out);
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/curl.js
+var require_curl = __commonJS({
+  "projects/@machina.at/shell/src/commands/curl.js"(exports2, module2) {
+    "use strict";
+    var netCommands = (init_net_commands(), __toCommonJS(net_commands_exports));
+    module2.exports = function curl2(args, ctx) {
+      return netCommands.curl(args, ctx);
+    };
+  }
+});
+
+// node_modules/fflate/esm/index.mjs
+function gunzipSync(data, opts) {
+  var st = gzs(data);
+  if (st + 8 > data.length)
+    err(6, "invalid gzip data");
+  return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
+}
+var import_module, require2, Worker, u8, u16, i32, fleb, fdeb, clim, freb, _a, fl, revfl, _b, fd, revfd, rev2, x, i, hMap, flt, i, i, i, i, fdt, i, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, et, gzs, gzl, td, tds;
+var init_esm = __esm({
+  "node_modules/fflate/esm/index.mjs"() {
+    "use strict";
+    import_module = require("module");
+    require2 = (0, import_module.createRequire)("/");
+    try {
+      Worker = require2("worker_threads").Worker;
+    } catch (e) {
+    }
+    u8 = Uint8Array;
+    u16 = Uint16Array;
+    i32 = Int32Array;
+    fleb = new u8([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      2,
+      2,
+      3,
+      3,
+      3,
+      3,
+      4,
+      4,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      0,
+      /* unused */
+      0,
+      0,
+      /* impossible */
+      0
+    ]);
+    fdeb = new u8([
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      2,
+      2,
+      3,
+      3,
+      4,
+      4,
+      5,
+      5,
+      6,
+      6,
+      7,
+      7,
+      8,
+      8,
+      9,
+      9,
+      10,
+      10,
+      11,
+      11,
+      12,
+      12,
+      13,
+      13,
+      /* unused */
+      0,
+      0
+    ]);
+    clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    freb = function(eb, start) {
+      var b = new u16(31);
+      for (var i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
+      }
+      var r = new i32(b[30]);
+      for (var i = 1; i < 30; ++i) {
+        for (var j = b[i]; j < b[i + 1]; ++j) {
+          r[j] = j - b[i] << 5 | i;
+        }
+      }
+      return { b, r };
+    };
+    _a = freb(fleb, 2);
+    fl = _a.b;
+    revfl = _a.r;
+    fl[28] = 258, revfl[258] = 28;
+    _b = freb(fdeb, 0);
+    fd = _b.b;
+    revfd = _b.r;
+    rev2 = new u16(32768);
+    for (i = 0; i < 32768; ++i) {
+      x = (i & 43690) >> 1 | (i & 21845) << 1;
+      x = (x & 52428) >> 2 | (x & 13107) << 2;
+      x = (x & 61680) >> 4 | (x & 3855) << 4;
+      rev2[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+    }
+    hMap = (function(cd, mb, r) {
+      var s = cd.length;
+      var i = 0;
+      var l = new u16(mb);
+      for (; i < s; ++i) {
+        if (cd[i])
+          ++l[cd[i] - 1];
+      }
+      var le = new u16(mb);
+      for (i = 1; i < mb; ++i) {
+        le[i] = le[i - 1] + l[i - 1] << 1;
+      }
+      var co;
+      if (r) {
+        co = new u16(1 << mb);
+        var rvb = 15 - mb;
+        for (i = 0; i < s; ++i) {
+          if (cd[i]) {
+            var sv = i << 4 | cd[i];
+            var r_1 = mb - cd[i];
+            var v = le[cd[i] - 1]++ << r_1;
+            for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+              co[rev2[v] >> rvb] = sv;
+            }
+          }
+        }
+      } else {
+        co = new u16(s);
+        for (i = 0; i < s; ++i) {
+          if (cd[i]) {
+            co[i] = rev2[le[cd[i] - 1]++] >> 15 - cd[i];
+          }
+        }
+      }
+      return co;
+    });
+    flt = new u8(288);
+    for (i = 0; i < 144; ++i)
+      flt[i] = 8;
+    for (i = 144; i < 256; ++i)
+      flt[i] = 9;
+    for (i = 256; i < 280; ++i)
+      flt[i] = 7;
+    for (i = 280; i < 288; ++i)
+      flt[i] = 8;
+    fdt = new u8(32);
+    for (i = 0; i < 32; ++i)
+      fdt[i] = 5;
+    flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+    fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+    max = function(a) {
+      var m = a[0];
+      for (var i = 1; i < a.length; ++i) {
+        if (a[i] > m)
+          m = a[i];
+      }
+      return m;
+    };
+    bits = function(d, p, m) {
+      var o = p / 8 | 0;
+      return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+    };
+    bits16 = function(d, p) {
+      var o = p / 8 | 0;
+      return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+    };
+    shft = function(p) {
+      return (p + 7) / 8 | 0;
+    };
+    slc = function(v, s, e) {
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      return new u8(v.subarray(s, e));
+    };
+    ec = [
+      "unexpected EOF",
+      "invalid block type",
+      "invalid length/literal",
+      "invalid distance",
+      "stream finished",
+      "no stream handler",
+      ,
+      "no callback",
+      "invalid UTF-8 data",
+      "extra field too long",
+      "date not in range 1980-2099",
+      "filename too long",
+      "stream finishing",
+      "invalid zip data"
+      // determined by unknown compression method
+    ];
+    err = function(ind, msg, nt) {
+      var e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+      if (!nt)
+        throw e;
+      return e;
+    };
+    inflt = function(dat, st, buf, dict) {
+      var sl = dat.length, dl = dict ? dict.length : 0;
+      if (!sl || st.f && !st.l)
+        return buf || new u8(0);
+      var noBuf = !buf;
+      var resize = noBuf || st.i != 2;
+      var noSt = st.i;
+      if (noBuf)
+        buf = new u8(sl * 3);
+      var cbuf = function(l2) {
+        var bl = buf.length;
+        if (l2 > bl) {
+          var nbuf = new u8(Math.max(bl * 2, l2));
+          nbuf.set(buf);
+          buf = nbuf;
+        }
+      };
+      var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+      var tbts = sl * 8;
+      do {
+        if (!lm) {
+          final = bits(dat, pos, 1);
+          var type = bits(dat, pos + 1, 3);
+          pos += 3;
+          if (!type) {
+            var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+            if (t > sl) {
+              if (noSt)
+                err(0);
+              break;
+            }
+            if (resize)
+              cbuf(bt + l);
+            buf.set(dat.subarray(s, t), bt);
+            st.b = bt += l, st.p = pos = t * 8, st.f = final;
+            continue;
+          } else if (type == 1)
+            lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+          else if (type == 2) {
+            var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+            var tl = hLit + bits(dat, pos + 5, 31) + 1;
+            pos += 14;
+            var ldt = new u8(tl);
+            var clt = new u8(19);
+            for (var i = 0; i < hcLen; ++i) {
+              clt[clim[i]] = bits(dat, pos + i * 3, 7);
+            }
+            pos += hcLen * 3;
+            var clb = max(clt), clbmsk = (1 << clb) - 1;
+            var clm = hMap(clt, clb, 1);
+            for (var i = 0; i < tl; ) {
+              var r = clm[bits(dat, pos, clbmsk)];
+              pos += r & 15;
+              var s = r >> 4;
+              if (s < 16) {
+                ldt[i++] = s;
+              } else {
+                var c = 0, n = 0;
+                if (s == 16)
+                  n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                else if (s == 17)
+                  n = 3 + bits(dat, pos, 7), pos += 3;
+                else if (s == 18)
+                  n = 11 + bits(dat, pos, 127), pos += 7;
+                while (n--)
+                  ldt[i++] = c;
+              }
+            }
+            var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+            lbt = max(lt);
+            dbt = max(dt);
+            lm = hMap(lt, lbt, 1);
+            dm = hMap(dt, dbt, 1);
+          } else
+            err(1);
+          if (pos > tbts) {
+            if (noSt)
+              err(0);
+            break;
+          }
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        var lpos = pos;
+        for (; ; lpos = pos) {
+          var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+          pos += c & 15;
+          if (pos > tbts) {
+            if (noSt)
+              err(0);
+            break;
+          }
+          if (!c)
+            err(2);
+          if (sym < 256)
+            buf[bt++] = sym;
+          else if (sym == 256) {
+            lpos = pos, lm = null;
+            break;
+          } else {
+            var add = sym - 254;
+            if (sym > 264) {
+              var i = sym - 257, b = fleb[i];
+              add = bits(dat, pos, (1 << b) - 1) + fl[i];
+              pos += b;
+            }
+            var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+            if (!d)
+              err(3);
+            pos += d & 15;
+            var dt = fd[dsym];
+            if (dsym > 3) {
+              var b = fdeb[dsym];
+              dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+            }
+            if (pos > tbts) {
+              if (noSt)
+                err(0);
+              break;
+            }
+            if (resize)
+              cbuf(bt + 131072);
+            var end = bt + add;
+            if (bt < dt) {
+              var shift = dl - dt, dend = Math.min(dt, end);
+              if (shift + bt < 0)
+                err(3);
+              for (; bt < dend; ++bt)
+                buf[bt] = dict[shift + bt];
+            }
+            for (; bt < end; ++bt)
+              buf[bt] = buf[bt - dt];
+          }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm)
+          final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+      } while (!final);
+      return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+    };
+    et = /* @__PURE__ */ new u8(0);
+    gzs = function(d) {
+      if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+        err(6, "invalid gzip data");
+      var flg = d[3];
+      var st = 10;
+      if (flg & 4)
+        st += (d[10] | d[11] << 8) + 2;
+      for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+        ;
+      return st + (flg & 2);
+    };
+    gzl = function(d) {
+      var l = d.length;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+    };
+    td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+    tds = 0;
+    try {
+      td.decode(et, { stream: true });
+      tds = 1;
+    } catch (e) {
+    }
+  }
+});
+
+// projects/@machina.at/shell/src/lib/tar-commands.ts
+var tar_commands_exports = {};
+__export(tar_commands_exports, {
+  tar: () => tar
+});
+function parseArgs2(args) {
+  const opts = { extract: false, list: false, gzip: false, file: null, dir: null, stripComponents: 0 };
+  const wants = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--strip-components")) {
+      const eq = a.indexOf("=");
+      if (eq >= 0) {
+        const n = parseInt(a.slice(eq + 1), 10);
+        if (!Number.isFinite(n) || n < 0) return { opts, error: `invalid --strip-components value '${a.slice(eq + 1)}'` };
+        opts.stripComponents = n;
+      } else {
+        wants.push("strip");
+      }
+      continue;
+    }
+    if (a.startsWith("-") && a.length > 1 && !a.startsWith("--")) {
+      for (const ch of a.slice(1)) {
+        if (ch === "x") opts.extract = true;
+        else if (ch === "t") opts.list = true;
+        else if (ch === "z") opts.gzip = true;
+        else if (ch === "f") wants.push("file");
+        else if (ch === "C") wants.push("dir");
+        else return { opts, error: `unknown option '-${ch}'` };
+      }
+    } else {
+      const target = wants.shift();
+      if (target === "dir") opts.dir = a;
+      else if (target === "strip") {
+        const n = parseInt(a, 10);
+        if (!Number.isFinite(n) || n < 0) return { opts, error: `invalid --strip-components value '${a}'` };
+        opts.stripComponents = n;
+      } else opts.file = a;
+    }
+  }
+  if (wants.includes("file")) return { opts, error: `option requires an argument -- 'f'` };
+  if (wants.includes("strip")) return { opts, error: `option requires an argument -- '--strip-components'` };
+  return { opts };
+}
+function stripPath(name, n) {
+  if (n <= 0) return name;
+  const parts = name.split("/").filter((p) => p.length > 0);
+  if (parts.length <= n) return null;
+  return parts.slice(n).join("/");
+}
+function parseTar(buf) {
+  const dec = new TextDecoder();
+  const str = (off, len) => dec.decode(buf.subarray(off, off + len)).replace(/\0.*$/, "").trim();
+  const entries = [];
+  let pos = 0;
+  while (pos + 512 <= buf.length) {
+    let allZero = true;
+    for (let i = 0; i < 512; i++) {
+      if (buf[pos + i] !== 0) {
+        allZero = false;
+        break;
+      }
+    }
+    if (allZero) break;
+    const name = str(pos, 100);
+    const sizeOct = str(pos + 124, 12);
+    const size = parseInt(sizeOct || "0", 8) || 0;
+    const typeflag = String.fromCharCode(buf[pos + 156]);
+    const dataStart = pos + 512;
+    pos = dataStart + Math.ceil(size / 512) * 512;
+    const isFile = typeflag === "0" || typeflag === "\0";
+    const isDir = typeflag === "5" || name.endsWith("/") && !isFile;
+    if (!name || !isFile && !isDir) continue;
+    const data = isDir ? new Uint8Array(0) : buf.subarray(dataStart, dataStart + size);
+    entries.push({ name: name.replace(/\/$/, ""), isDir, data });
+  }
+  return entries;
+}
+function tar(args, ctx) {
+  const stderr = ctx.stderr ?? process.stderr;
+  const stdout = ctx.stdout ?? process.stdout;
+  const parsed = parseArgs2(args);
+  if (parsed.error) {
+    stderr.write(`tar: ${parsed.error}
+`);
+    return 2;
+  }
+  const opts = parsed.opts;
+  if (!opts.extract && !opts.list) {
+    stderr.write("tar: you must specify one of -x or -t\n");
+    return 2;
+  }
+  if (!opts.file) {
+    stderr.write("tar: no archive file specified (-f)\n");
+    return 2;
+  }
+  let raw;
+  try {
+    const read = ctx.fs.readFileSync(opts.file);
+    raw = typeof read === "string" ? new TextEncoder().encode(read) : read;
+  } catch (err2) {
+    stderr.write(`tar: ${opts.file}: ${err2.message ?? "cannot open"}
+`);
+    return 2;
+  }
+  let tarBuf;
+  try {
+    tarBuf = opts.gzip ? gunzipSync(raw) : raw;
+  } catch (err2) {
+    stderr.write(`tar: gunzip failed: ${err2.message ?? String(err2)}
+`);
+    return 2;
+  }
+  let entries;
+  try {
+    entries = parseTar(tarBuf);
+  } catch (err2) {
+    stderr.write(`tar: parse failed: ${err2.message ?? String(err2)}
+`);
+    return 2;
+  }
+  const baseDir = opts.dir ?? ctx.cwd;
+  for (const e of entries) {
+    if (opts.list) {
+      stdout.write(e.name + "\n");
+      continue;
+    }
+    const stripped = stripPath(e.name, opts.stripComponents);
+    if (stripped === null) continue;
+    const dest = ctx.path.join(baseDir, stripped);
+    try {
+      if (e.isDir) {
+        ctx.fs.mkdirSync(dest, { recursive: true });
+      } else {
+        const parent = ctx.path.dirname(dest);
+        ctx.fs.mkdirSync(parent, { recursive: true });
+        ctx.fs.writeFileSync(dest, e.data);
+      }
+    } catch (err2) {
+      stderr.write(`tar: ${e.name}: ${err2.message ?? String(err2)}
+`);
+      return 2;
+    }
+  }
+  return 0;
+}
+var init_tar_commands = __esm({
+  "projects/@machina.at/shell/src/lib/tar-commands.ts"() {
+    "use strict";
+    init_esm();
+  }
+});
+
+// projects/@machina.at/shell/src/commands/tar.js
+var require_tar = __commonJS({
+  "projects/@machina.at/shell/src/commands/tar.js"(exports2, module2) {
+    "use strict";
+    var tarCommands = (init_tar_commands(), __toCommonJS(tar_commands_exports));
+    module2.exports = function tar2(args, ctx) {
+      return tarCommands.tar(args, ctx);
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/commands/index.js
+var require_commands = __commonJS({
+  "projects/@machina.at/shell/src/commands/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports.ls = require_ls();
+    module2.exports.cat = require_cat();
+    module2.exports.echo = require_echo();
+    module2.exports.pwd = require_pwd();
+    module2.exports.mkdir = require_mkdir();
+    module2.exports.head = require_head();
+    module2.exports.tail = require_tail();
+    module2.exports.env = require_env();
+    module2.exports.which = require_which();
+    module2.exports.help = require_help();
+    module2.exports.clear = require_clear();
+    module2.exports.test = require_test();
+    module2.exports["["] = require_test();
+    module2.exports["true"] = require_true();
+    module2.exports["false"] = require_false();
+    module2.exports.cp = require_cp();
+    module2.exports.mv = require_mv();
+    module2.exports.rm = require_rm();
+    module2.exports.rmdir = require_rmdir();
+    module2.exports.touch = require_touch();
+    module2.exports.ln = require_ln();
+    module2.exports.grep = require_grep();
+    module2.exports.sed = require_sed();
+    module2.exports.wc = require_wc();
+    module2.exports.sort = require_sort();
+    module2.exports.uniq = require_uniq();
+    module2.exports.cut = require_cut();
+    module2.exports.tr = require_tr();
+    module2.exports.tee = require_tee();
+    module2.exports.printf = require_printf();
+    module2.exports.find = require_find();
+    module2.exports.xargs = require_xargs();
+    module2.exports.sleep = require_sleep();
+    module2.exports.date = require_date();
+    module2.exports.basename = require_basename();
+    module2.exports.dirname = require_dirname();
+    module2.exports.bit = require_bit();
+    module2.exports.seq = require_seq();
+    module2.exports.readlink = require_readlink();
+    module2.exports.realpath = require_realpath();
+    module2.exports.mktemp = require_mktemp();
+    module2.exports.expr = require_expr();
+    module2.exports.yes = require_yes();
+    module2.exports.whoami = require_whoami();
+    module2.exports.uname = require_uname();
+    module2.exports.chmod = require_chmod();
+    module2.exports.nl = require_nl();
+    module2.exports.paste = require_paste();
+    module2.exports.rev = require_rev();
+    module2.exports.curl = require_curl();
+    module2.exports.tar = require_tar();
+  }
+});
+
+// projects/@machina.at/shell/src/lib/parse-bg.ts
+var parse_bg_exports = {};
+__export(parse_bg_exports, {
+  parseTrailingBg: () => parseTrailingBg
+});
+function parseTrailingBg(line) {
+  if (typeof line !== "string") return { command: line, bgMode: false };
+  const trimmed = line.replace(/\s+$/, "");
+  if (trimmed.length === 0) return { command: line, bgMode: false };
+  const lastIdx = trimmed.length - 1;
+  if (trimmed.charAt(lastIdx) !== "&") return { command: line, bgMode: false };
+  let inQuote = false;
+  let quoteChar = "";
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed.charAt(i);
+    if (inQuote) {
+      if (ch === quoteChar && trimmed.charAt(i - 1) !== "\\") {
+        inQuote = false;
+      }
+    } else if (ch === '"' || ch === "'") {
+      inQuote = true;
+      quoteChar = ch;
+    }
+  }
+  if (inQuote) return { command: line, bgMode: false };
+  if (lastIdx >= 1 && trimmed.charAt(lastIdx - 1) === "&") {
+    return { command: line, bgMode: false };
+  }
+  const withoutBg = trimmed.slice(0, lastIdx).replace(/\s+$/, "");
+  return { command: withoutBg, bgMode: true };
+}
+var init_parse_bg = __esm({
+  "projects/@machina.at/shell/src/lib/parse-bg.ts"() {
+    "use strict";
+  }
+});
+
+// projects/@machina.at/shell/src/lib/job-table.ts
+var job_table_exports = {};
+__export(job_table_exports, {
+  JobTable: () => JobTable
+});
+function formatStatus(status) {
+  switch (status.kind) {
+    case "running":
+      return "Running";
+    case "done":
+      return "Done";
+    case "exit":
+      return `Exit ${status.code}`;
+  }
+}
+var JobTable;
+var init_job_table = __esm({
+  "projects/@machina.at/shell/src/lib/job-table.ts"() {
+    "use strict";
+    JobTable = class {
+      jobs = /* @__PURE__ */ new Map();
+      nextId = 0;
+      add(cmd, child) {
+        const id = ++this.nextId;
+        this.jobs.set(id, { id, cmd, status: { kind: "running" }, child });
+        return id;
+      }
+      attachChild(id, child) {
+        const job = this.jobs.get(id);
+        if (job) job.child = child;
+      }
+      getChildByRef(ref) {
+        return this.findByRef(ref)?.child;
+      }
+      finish(id, exitCode) {
+        const job = this.jobs.get(id);
+        if (!job) return;
+        job.status = exitCode === 0 ? { kind: "done" } : { kind: "exit", code: exitCode };
+      }
+      listRunning() {
+        return [...this.jobs.values()].filter((j) => j.status.kind === "running");
+      }
+      listAll() {
+        return [...this.jobs.values()];
+      }
+      pruneFinished() {
+        for (const [id, job] of this.jobs) {
+          if (job.status.kind !== "running") {
+            this.jobs.delete(id);
+          }
+        }
+      }
+      findByRef(ref) {
+        if (!ref || !ref.startsWith("%")) return void 0;
+        const tail2 = ref.slice(1);
+        const list = this.listAll().sort((a, b) => a.id - b.id);
+        if (list.length === 0) return void 0;
+        if (tail2 === "+" || tail2 === "%" || tail2 === "") {
+          return list[list.length - 1];
+        }
+        if (tail2 === "-") {
+          return list.length >= 2 ? list[list.length - 2] : list[list.length - 1];
+        }
+        if (/^\d+$/.test(tail2)) {
+          const id = parseInt(tail2, 10);
+          return this.jobs.get(id);
+        }
+        return void 0;
+      }
+      format() {
+        const list = this.listAll();
+        if (list.length === 0) return "";
+        list.sort((a, b) => a.id - b.id);
+        const last = list[list.length - 1]?.id;
+        const prev = list[list.length - 2]?.id;
+        return list.map((j) => {
+          const marker = j.id === last ? "+" : j.id === prev ? "-" : " ";
+          const status = formatStatus(j.status);
+          return `[${j.id}]${marker} ${status.padEnd(11)}${j.cmd}`;
+        }).join("\n");
+      }
+    };
+  }
+});
+
+// projects/@machina.at/shell/src/lib/path-resolve.ts
+var path_resolve_exports = {};
+__export(path_resolve_exports, {
+  resolveInPath: () => resolveInPath
+});
+function resolveInPath(cmdName, ctx) {
+  if (cmdName.includes("/")) return null;
+  const PATH = ctx.env.PATH;
+  if (!PATH) return null;
+  for (const dir of PATH.split(":")) {
+    if (!dir) continue;
+    const candidate = ctx.path.join(dir, cmdName);
+    try {
+      if (ctx.fs.existsSync(candidate) && ctx.fs.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    } catch (_e) {
+    }
+  }
+  return null;
+}
+var init_path_resolve = __esm({
+  "projects/@machina.at/shell/src/lib/path-resolve.ts"() {
+    "use strict";
+  }
+});
+
+// projects/@machina.at/shell/src/lib/rc-loader.ts
+var rc_loader_exports = {};
+__export(rc_loader_exports, {
+  listRcFiles: () => listRcFiles
+});
+function listRcFiles(ctx) {
+  const candidates = [];
+  if (ctx.env.HOME) candidates.push(ctx.path.join(ctx.env.HOME, ".xshrc"));
+  const result = [];
+  for (const file of candidates) {
+    try {
+      if (ctx.fs.statSync(file).isFile()) result.push(file);
+    } catch (_e) {
+    }
+  }
+  return result;
+}
+var init_rc_loader = __esm({
+  "projects/@machina.at/shell/src/lib/rc-loader.ts"() {
+    "use strict";
+  }
+});
+
+// projects/@machina.at/shell/src/commands/sh.js
+var require_sh = __commonJS({
+  "projects/@machina.at/shell/src/commands/sh.js"() {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var commands = require_commands();
+    var parseBg = (init_parse_bg(), __toCommonJS(parse_bg_exports));
+    var JobTableModule = (init_job_table(), __toCommonJS(job_table_exports));
+    var pathResolveModule = (init_path_resolve(), __toCommonJS(path_resolve_exports));
+    var rcLoaderModule = (init_rc_loader(), __toCommonJS(rc_loader_exports));
+    var jobTable = new JobTableModule.JobTable();
+    function charWidth(ch) {
+      var code = ch.charCodeAt(0);
+      if (code >= 4352 && code <= 4447 || // Hangul Jamo
+      code >= 11904 && code <= 12350 || // CJK Radicals
+      code >= 12352 && code <= 13247 || // Hiragana, Katakana, CJK
+      code >= 13312 && code <= 19903 || // CJK Extension A
+      code >= 19968 && code <= 40959 || // CJK Unified
+      code >= 44032 && code <= 55215 || // Hangul Syllables
+      code >= 63744 && code <= 64255 || // CJK Compatibility
+      code >= 65072 && code <= 65135 || // CJK Compatibility Forms
+      code >= 65281 && code <= 65376 || // Fullwidth Forms
+      code >= 65504 && code <= 65510 || // Fullwidth Signs
+      code >= 131072 && code <= 195103) {
+        return 2;
+      }
+      return 1;
+    }
+    function strWidth(s) {
+      var w = 0;
+      for (var i = 0; i < s.length; i++) w += charWidth(s[i]);
+      return w;
+    }
+    var cwd = process.cwd() || "/";
+    var env = Object.assign({}, process.env);
+    var exitCode = 0;
+    var asyncRunning = false;
+    var pendingChain = null;
+    function prompt() {
+      process.stdout.write("\x1B[1;32m$ \x1B[0m");
+    }
+    function parseCommandLine(line) {
+      var args = [];
+      var current = "";
+      var inQuote = false;
+      var quoteChar = "";
+      for (var i = 0; i < line.length; i++) {
+        var ch = line[i];
+        if (inQuote) {
+          if (ch === quoteChar) {
+            inQuote = false;
+          } else {
+            current += ch;
+          }
+        } else if (ch === '"' || ch === "'") {
+          inQuote = true;
+          quoteChar = ch;
+        } else if (ch === " " || ch === "	") {
+          if (current) {
+            args.push(current);
+            current = "";
+          }
+        } else {
+          current += ch;
+        }
+      }
+      if (current) args.push(current);
+      return args;
+    }
+    function executeCommand(line, bgMode) {
+      var trimmed = line.trim();
+      if (!trimmed) return 0;
+      bgMode = !!bgMode;
+      var chain = splitChainLocal(trimmed);
+      return runChainFrom(chain, 0, bgMode, false);
+    }
+    function runChainFrom(chain, startIdx, bgMode, skip) {
+      for (var idx = startIdx; idx < chain.length; idx++) {
+        var item = chain[idx];
+        if (!item.cmd) continue;
+        if (skip) {
+          skip = false;
+          if (item.operator === "||" && exitCode !== 0) {
+            skip = false;
+          } else if (item.operator === "&&" && exitCode === 0) {
+            skip = false;
+          } else {
+            continue;
+          }
+        }
+        var isLast = idx === chain.length - 1;
+        exitCode = executeSingle(expandVars(item.cmd), bgMode && isLast);
+        if (exitCode === -1 && asyncRunning && !isLast) {
+          pendingChain = { chain, nextIdx: idx + 1, bgMode, lastOp: item.operator };
+          return -1;
+        }
+        if (item.operator === "&&" && exitCode !== 0) skip = true;
+        else if (item.operator === "||" && exitCode === 0) skip = true;
+      }
+      return exitCode;
+    }
+    function executeSingle(line, bgMode) {
+      bgMode = !!bgMode;
+      var parsed = parseRedirects(line);
+      var command = parsed.command;
+      var redir = parsed.redirects;
+      var stdinData = null;
+      if (redir.stdin) {
+        var stdinPath = redir.stdin.startsWith("/") ? redir.stdin : path.join(cwd, redir.stdin);
+        try {
+          var content = fs.readFileSync(stdinPath);
+          stdinData = typeof content === "string" ? content : new TextDecoder().decode(content);
+        } catch (err2) {
+          process.stderr.write("sh: " + redir.stdin + ": no such file or directory\n");
+          return 1;
+        }
+      }
+      var hasPipe = command.indexOf("|") !== -1;
+      var capturedStdout = "";
+      var capturedStderr = "";
+      var captureStdout = !!redir.stdout;
+      var captureStderr = !!redir.stderr;
+      var result;
+      if (hasPipe) {
+        result = executePipeline(command, stdinData, captureStdout, captureStderr);
+      } else {
+        result = executeSimple(command, stdinData, captureStdout, captureStderr, bgMode);
+      }
+      if (redir.stdout && result.stdout) {
+        var outPath = redir.stdout.startsWith("/") ? redir.stdout : path.join(cwd, redir.stdout);
+        if (redir.stdoutAppend) fs.appendFileSync(outPath, result.stdout);
+        else fs.writeFileSync(outPath, result.stdout);
+      }
+      if (redir.stderr && result.stderr) {
+        var errPath = redir.stderr.startsWith("/") ? redir.stderr : path.join(cwd, redir.stderr);
+        fs.writeFileSync(errPath, result.stderr);
+      }
+      return result.exitCode;
+    }
+    function parseRedirects(line) {
+      var redirects = { stdout: null, stdoutAppend: false, stdin: null, stderr: null };
+      var command = line;
+      var m;
+      m = command.match(/\s+2>\s+(\S+)/);
+      if (m) {
+        redirects.stderr = m[1];
+        command = command.replace(m[0], " ");
+      }
+      m = command.match(/\s*>>\s+(\S+)/);
+      if (m) {
+        redirects.stdout = m[1];
+        redirects.stdoutAppend = true;
+        command = command.replace(m[0], " ");
+      }
+      if (!redirects.stdout) {
+        m = command.match(/\s*>\s+(\S+)/);
+        if (m) {
+          redirects.stdout = m[1];
+          command = command.replace(m[0], " ");
+        }
+      }
+      m = command.match(/\s*<\s+(\S+)/);
+      if (m) {
+        redirects.stdin = m[1];
+        command = command.replace(m[0], " ");
+      }
+      return { command: command.trim(), redirects };
+    }
+    function executePipeline(line, stdinData, captureStdout, captureStderr) {
+      var stages = line.split("|");
+      var data = stdinData;
+      var lastExitCode = 0;
+      var lastStderr = "";
+      for (var i = 0; i < stages.length; i++) {
+        var stage = stages[i].trim();
+        if (!stage) continue;
+        var isLast = true;
+        for (var j = i + 1; j < stages.length; j++) {
+          if (stages[j].trim()) {
+            isLast = false;
+            break;
+          }
+        }
+        var result = executeSimple(stage, data, !isLast || captureStdout, captureStderr);
+        lastExitCode = result.exitCode;
+        lastStderr += result.stderr || "";
+        data = result.stdout || "";
+      }
+      return { exitCode: lastExitCode, stdout: captureStdout ? data : "", stderr: lastStderr };
+    }
+    function executeSimple(line, stdinData, captureStdout, captureStderr, bgMode) {
+      bgMode = !!bgMode;
+      var args = parseCommandLine(line);
+      if (args.length === 0) return { exitCode: 0, stdout: "", stderr: "" };
+      args = expandGlobsLocal(args);
+      var cmdName = args[0];
+      var cmdArgs = args.slice(1);
+      if (cmdName === "cd") return { exitCode: builtinCd(cmdArgs), stdout: "", stderr: "" };
+      if (cmdName === "jobs") {
+        var out = jobTable.format();
+        if (out) process.stdout.write(out + "\n");
+        jobTable.pruneFinished();
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (cmdName === "export") return { exitCode: builtinExport(cmdArgs), stdout: "", stderr: "" };
+      if (cmdName === "exit") {
+        process.exit(cmdArgs[0] ? parseInt(cmdArgs[0], 10) : 0);
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (cmdName === "set") return { exitCode: builtinSet(cmdArgs), stdout: "", stderr: "" };
+      if (cmdName === "unset") return { exitCode: builtinUnset(cmdArgs), stdout: "", stderr: "" };
+      if (cmdName === "read") return { exitCode: builtinRead(cmdArgs, stdinData), stdout: "", stderr: "" };
+      if (cmdName === "source" || cmdName === ".") return { exitCode: builtinSource(cmdArgs), stdout: "", stderr: "" };
+      var resolved = pathResolveModule.resolveInPath(cmdName, { env, fs, path });
+      if (resolved) {
+        var head2 = null;
+        try {
+          var fd2 = fs.openSync(resolved, "r");
+          head2 = Buffer.alloc(4);
+          fs.readSync(fd2, head2, 0, 4, 0);
+          fs.closeSync(fd2);
+        } catch (_e) {
+          head2 = null;
+        }
+        var isShebang = head2 && head2[0] === 35 && head2[1] === 33;
+        var isBinary = head2 && (head2[0] === 127 && head2[1] === 69 && head2[2] === 76 && head2[3] === 70 || // ELF
+        (head2[0] === 207 || head2[0] === 206) && head2[1] === 250 && head2[2] === 237 && head2[3] === 254 || // Mach-O LE
+        head2[0] === 254 && head2[1] === 237 && head2[2] === 250 && (head2[3] === 207 || head2[3] === 206) || // Mach-O BE
+        head2[0] === 202 && head2[1] === 254 && head2[2] === 186 && head2[3] === 190 || // Mach-O Fat
+        head2[0] === 77 && head2[1] === 90);
+        if (!isShebang && !isBinary) {
+          return { exitCode: builtinSource([resolved].concat(cmdArgs)), stdout: "", stderr: "" };
+        }
+        cmdName = resolved;
+      } else {
+        var cmd = commands[cmdName];
+        if (cmd) {
+          var capturedOut = "";
+          var capturedErr = "";
+          var origOut = process.stdout.write;
+          var origErr = process.stderr.write;
+          if (captureStdout) {
+            process.stdout.write = function(d) {
+              capturedOut += d;
+              return true;
+            };
+          }
+          if (captureStderr) {
+            process.stderr.write = function(d) {
+              capturedErr += d;
+              return true;
+            };
+          }
+          var ctx = { cwd, env, fs, path, stdin: stdinData };
+          var code;
+          try {
+            code = cmd(cmdArgs, ctx);
+          } catch (err2) {
+            process.stderr.write("sh: " + cmdName + ": " + (err2.message || err2) + "\n");
+            code = 1;
+          } finally {
+            if (captureStdout) process.stdout.write = origOut;
+            if (captureStderr) process.stderr.write = origErr;
+          }
+          return { exitCode: code, stdout: capturedOut, stderr: capturedErr };
+        }
+      }
+      var isWebkernel = env && env.PLANX_WEBKERNEL === "1";
+      var cp2 = require("child_process");
+      var spawnOpts = { cwd, env };
+      if (!bgMode && !isWebkernel) {
+        spawnOpts.stdio = "inherit";
+        if (process.stdin.setRawMode) process.stdin.setRawMode(false);
+        process.stdin.pause();
+      }
+      var child = cp2.spawn(cmdName, cmdArgs, spawnOpts);
+      if (bgMode || isWebkernel) {
+        child.stdout && child.stdout.on("data", function(d) {
+          process.stdout.write(typeof d === "string" ? d : d.toString());
+        });
+        child.stderr && child.stderr.on("data", function(d) {
+          process.stderr.write(typeof d === "string" ? d : d.toString());
+        });
+      }
+      child.on("error", function(e) {
+        process.stderr.write("sh: " + cmdName + ": " + (e.message || e) + "\n");
+      });
+      if (bgMode) {
+        var bgCmdLine = [cmdName].concat(cmdArgs).join(" ");
+        var jobId = jobTable.add(bgCmdLine);
+        process.stderr.write("[" + jobId + "] " + cmdName + "\n");
+        child.on("close", function(code2) {
+          var c = typeof code2 === "number" ? code2 : 0;
+          exitCode = c;
+          jobTable.finish(jobId, c);
+          var statusText = c === 0 ? "Done" : "Exit " + c;
+          process.stderr.write("[" + jobId + "]+ " + statusText + " " + cmdName + "\n");
+        });
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      child.on("close", function(code2) {
+        exitCode = typeof code2 === "number" ? code2 : 0;
+        asyncRunning = false;
+        if (pendingChain) {
+          var pc = pendingChain;
+          pendingChain = null;
+          var initialSkip = pc.lastOp === "&&" && exitCode !== 0 || pc.lastOp === "||" && exitCode === 0;
+          asyncRunning = true;
+          var rc = runChainFrom(pc.chain, pc.nextIdx, pc.bgMode, initialSkip);
+          if (rc === -1) return;
+          asyncRunning = false;
+        }
+        process.stdin.resume();
+        if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+        prompt();
+        processInputBuffer();
+      });
+      return { exitCode: -1, stdout: "", stderr: "" };
+    }
+    function builtinSet(args) {
+      if (args.length === 0) {
+        for (var key in env) {
+          process.stdout.write(key + "=" + env[key] + "\n");
+        }
+        return 0;
+      }
+      for (var i = 0; i < args.length; i++) {
+        if (args[i].startsWith("-")) continue;
+        var eq = args[i].indexOf("=");
+        if (eq !== -1) {
+          env[args[i].substring(0, eq)] = args[i].substring(eq + 1);
+        }
+      }
+      return 0;
+    }
+    function builtinUnset(args) {
+      for (var i = 0; i < args.length; i++) {
+        if (!args[i].startsWith("-")) delete env[args[i]];
+      }
+      return 0;
+    }
+    function builtinRead(args, stdinData) {
+      var varNames = [];
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] === "-p" && args[i + 1]) {
+          i++;
+          continue;
+        }
+        if (!args[i].startsWith("-")) varNames.push(args[i]);
+      }
+      var input = stdinData || "";
+      var firstLine = input.split("\n")[0] || "";
+      var parts = firstLine.split(/\s+/);
+      if (varNames.length === 0) {
+        env["REPLY"] = firstLine;
+      } else {
+        for (var j = 0; j < varNames.length; j++) {
+          env[varNames[j]] = j === varNames.length - 1 ? parts.slice(j).join(" ") : parts[j] || "";
+        }
+      }
+      return input ? 0 : 1;
+    }
+    function builtinSource(args) {
+      if (args.length === 0) {
+        process.stderr.write("source: missing file operand\n");
+        return 1;
+      }
+      var filePath = args[0].startsWith("/") ? args[0] : path.join(cwd, args[0]);
+      var rawContent;
+      try {
+        var raw = fs.readFileSync(filePath);
+        rawContent = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+      } catch (err2) {
+        process.stderr.write("source: " + args[0] + ": " + err2.message + "\n");
+        return 1;
+      }
+      var lastCode = 0;
+      var lines = rawContent.split("\n");
+      for (var i = 0; i < lines.length; i++) {
+        var trimmed = lines[i].trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        lastCode = executeCommand(trimmed);
+      }
+      return lastCode;
+    }
+    function builtinCd(args) {
+      var target = args[0] || env.HOME || "/";
+      if (target === "-") {
+        target = env.OLDPWD || cwd;
+      }
+      var newCwd;
+      if (target.startsWith("/")) {
+        newCwd = target;
+      } else if (target === "..") {
+        newCwd = path.dirname(cwd);
+      } else {
+        newCwd = path.join(cwd, target);
+      }
+      newCwd = path.normalize(newCwd);
+      try {
+        var stat = fs.statSync(newCwd);
+        if (!stat.isDirectory()) {
+          process.stderr.write("cd: not a directory: " + target + "\n");
+          return 1;
+        }
+        env.OLDPWD = cwd;
+        cwd = newCwd;
+        process.chdir(newCwd);
+        return 0;
+      } catch (e) {
+        process.stderr.write("cd: no such file or directory: " + target + "\n");
+        return 1;
+      }
+    }
+    function builtinExport(args) {
+      for (var i = 0; i < args.length; i++) {
+        var eq = args[i].indexOf("=");
+        if (eq === -1) {
+          process.stderr.write("export: invalid identifier: " + args[i] + "\n");
+          return 1;
+        }
+        var key = args[i].substring(0, eq);
+        var value = args[i].substring(eq + 1);
+        env[key] = value;
+        process.env[key] = value;
+      }
+      return 0;
+    }
+    function expandVars(input) {
+      var result = "";
+      var i = 0;
+      while (i < input.length) {
+        if (input[i] === "'") {
+          result += "'";
+          i++;
+          while (i < input.length && input[i] !== "'") {
+            result += input[i];
+            i++;
+          }
+          if (i < input.length) {
+            result += "'";
+            i++;
+          }
+          continue;
+        }
+        if (input[i] === "\\" && i + 1 < input.length) {
+          result += input[i] + input[i + 1];
+          i += 2;
+          continue;
+        }
+        if (input[i] === "$" && input[i + 1] === "(" && input[i + 2] === "(") {
+          i += 3;
+          var expr2 = "";
+          while (i < input.length && !(input[i] === ")" && input[i + 1] === ")")) {
+            expr2 += input[i];
+            i++;
+          }
+          i += 2;
+          try {
+            result += evalSimpleArith(expr2);
+          } catch (_e) {
+            result += "0";
+          }
+          continue;
+        }
+        if (input[i] === "$" && input[i + 1] === "?") {
+          result += exitCode.toString();
+          i += 2;
+          continue;
+        }
+        if (input[i] === "$" && input[i + 1] === "$") {
+          result += process.pid.toString();
+          i += 2;
+          continue;
+        }
+        if (input[i] === "$" && input[i + 1] === "{") {
+          i += 2;
+          var braceContent = "";
+          while (i < input.length && input[i] !== "}") {
+            braceContent += input[i];
+            i++;
+          }
+          if (i < input.length) i++;
+          if (braceContent[0] === "#") {
+            var vn = braceContent.slice(1);
+            result += (env[vn] || "").length.toString();
+          } else if (braceContent.indexOf(":-") !== -1) {
+            var parts = braceContent.split(":-");
+            result += env[parts[0]] || parts[1] || "";
+          } else if (braceContent.indexOf(":+") !== -1) {
+            var parts2 = braceContent.split(":+");
+            result += env[parts2[0]] ? parts2[1] : "";
+          } else {
+            result += env[braceContent] || "";
+          }
+          continue;
+        }
+        if (input[i] === "$" && i + 1 < input.length && /[a-zA-Z_]/.test(input[i + 1])) {
+          i++;
+          var name = "";
+          while (i < input.length && /[a-zA-Z0-9_]/.test(input[i])) {
+            name += input[i];
+            i++;
+          }
+          result += env[name] || "";
+          continue;
+        }
+        if (input[i] === "~" && (i === 0 || input[i - 1] === " " || input[i - 1] === "=")) {
+          if (i + 1 >= input.length || input[i + 1] === "/" || input[i + 1] === " ") {
+            result += env.HOME || "/";
+            i++;
+            continue;
+          }
+        }
+        if (input[i] === '"') {
+          result += '"';
+          i++;
+          while (i < input.length && input[i] !== '"') {
+            if (input[i] === "$") {
+              if (input[i + 1] === "?") {
+                result += exitCode.toString();
+                i += 2;
+                continue;
+              }
+              if (input[i + 1] === "{") {
+                i += 2;
+                var bc = "";
+                while (i < input.length && input[i] !== "}") {
+                  bc += input[i];
+                  i++;
+                }
+                if (i < input.length) i++;
+                if (bc.indexOf(":-") !== -1) {
+                  var p = bc.split(":-");
+                  result += env[p[0]] || p[1] || "";
+                } else {
+                  result += env[bc] || "";
+                }
+                continue;
+              }
+              if (/[a-zA-Z_]/.test(input[i + 1] || "")) {
+                i++;
+                var n2 = "";
+                while (i < input.length && /[a-zA-Z0-9_]/.test(input[i])) {
+                  n2 += input[i];
+                  i++;
+                }
+                result += env[n2] || "";
+                continue;
+              }
+            }
+            if (input[i] === "\\" && i + 1 < input.length) {
+              var next = input[i + 1];
+              if (next === "$" || next === '"' || next === "\\") {
+                result += next;
+                i += 2;
+                continue;
+              }
+            }
+            result += input[i];
+            i++;
+          }
+          if (i < input.length) {
+            result += '"';
+            i++;
+          }
+          continue;
+        }
+        result += input[i];
+        i++;
+      }
+      return result;
+    }
+    function evalSimpleArith(expr2) {
+      var resolved = expr2.replace(/[a-zA-Z_]\w*/g, function(name) {
+        return env[name] || "0";
+      });
+      var val = 0;
+      try {
+        if (/^[\d+\-*/%() <>=!&|]+$/.test(resolved.trim())) {
+          val = new Function("return (" + resolved + ")")();
+        }
+      } catch (_e) {
+      }
+      return (val | 0).toString();
+    }
+    function splitChainLocal(line) {
+      var result = [];
+      var current = "";
+      var inSingle = false, inDouble = false;
+      for (var i = 0; i < line.length; i++) {
+        var ch = line[i];
+        if (ch === "'" && !inDouble) {
+          inSingle = !inSingle;
+          current += ch;
+          continue;
+        }
+        if (ch === '"' && !inSingle) {
+          inDouble = !inDouble;
+          current += ch;
+          continue;
+        }
+        if (inSingle || inDouble) {
+          current += ch;
+          continue;
+        }
+        if (ch === "&" && line[i + 1] === "&") {
+          result.push({ cmd: current.trim(), operator: "&&" });
+          current = "";
+          i++;
+          continue;
+        }
+        if (ch === "|" && line[i + 1] === "|") {
+          result.push({ cmd: current.trim(), operator: "||" });
+          current = "";
+          i++;
+          continue;
+        }
+        if (ch === ";") {
+          result.push({ cmd: current.trim(), operator: ";" });
+          current = "";
+          continue;
+        }
+        current += ch;
+      }
+      if (current.trim()) result.push({ cmd: current.trim(), operator: null });
+      return result;
+    }
+    function expandGlobsLocal(args) {
+      var result = [];
+      for (var a = 0; a < args.length; a++) {
+        var arg = args[a];
+        if (arg.indexOf("*") !== -1 || arg.indexOf("?") !== -1) {
+          var dir = path.dirname(arg);
+          var base = path.basename(arg);
+          var absDir = dir.startsWith("/") ? dir : path.join(cwd, dir);
+          try {
+            var entries = fs.readdirSync(absDir);
+            var re = globToRe(base);
+            var matched = entries.filter(function(e) {
+              return re.test(e);
+            }).sort();
+            if (matched.length > 0) {
+              for (var m = 0; m < matched.length; m++) {
+                result.push(dir === "." ? matched[m] : path.join(dir, matched[m]));
+              }
+              continue;
+            }
+          } catch (_e) {
+          }
+        }
+        result.push(arg);
+      }
+      return result;
+    }
+    function globToRe(pattern) {
+      var re = "";
+      for (var i = 0; i < pattern.length; i++) {
+        var ch = pattern[i];
+        if (ch === "*") re += ".*";
+        else if (ch === "?") re += ".";
+        else if (".+^${}()|[]\\".indexOf(ch) !== -1) re += "\\" + ch;
+        else re += ch;
+      }
+      return new RegExp("^" + re + "$");
+    }
+    var inputBuffer = "";
+    var cursorPos = 0;
+    var commandHistory = [];
+    var historyIndex = -1;
+    var savedInput = "";
+    var completionMenu = null;
+    var menuVisible = false;
+    function wordLeft() {
+      if (cursorPos === 0) return;
+      var pos = cursorPos;
+      while (pos > 0 && inputBuffer[pos - 1] === " ") pos--;
+      while (pos > 0 && inputBuffer[pos - 1] !== " ") pos--;
+      var moved = strWidth(inputBuffer.slice(pos, cursorPos));
+      if (moved > 0) {
+        process.stdout.write("\x1B[" + moved + "D");
+        cursorPos = pos;
+      }
+    }
+    function wordRight() {
+      var len = inputBuffer.length;
+      if (cursorPos >= len) return;
+      var pos = cursorPos;
+      while (pos < len && inputBuffer[pos] !== " ") pos++;
+      while (pos < len && inputBuffer[pos] === " ") pos++;
+      var moved = strWidth(inputBuffer.slice(cursorPos, pos));
+      if (moved > 0) {
+        process.stdout.write("\x1B[" + moved + "C");
+        cursorPos = pos;
+      }
+    }
+    function deleteWordBack() {
+      if (cursorPos === 0) return;
+      var pos = cursorPos;
+      while (pos > 0 && inputBuffer[pos - 1] === " ") pos--;
+      while (pos > 0 && inputBuffer[pos - 1] !== " ") pos--;
+      var delCount = cursorPos - pos;
+      if (delCount === 0) return;
+      var delWidth = strWidth(inputBuffer.slice(pos, cursorPos));
+      var tail2 = inputBuffer.slice(cursorPos);
+      var tailWidth = strWidth(tail2);
+      inputBuffer = inputBuffer.slice(0, pos) + tail2;
+      cursorPos = pos;
+      process.stdout.write("\x1B[" + delWidth + "D" + tail2 + " ".repeat(delWidth) + "\x1B[" + (tailWidth + delWidth) + "D");
+    }
+    function replaceLine(newLine) {
+      var oldWidth = strWidth(inputBuffer.slice(0, cursorPos));
+      if (oldWidth > 0) {
+        process.stdout.write("\x1B[" + oldWidth + "D");
+      }
+      process.stdout.write("\x1B[K");
+      inputBuffer = newLine;
+      cursorPos = newLine.length;
+      process.stdout.write(newLine);
+    }
+    function historyUp() {
+      if (commandHistory.length === 0) return;
+      var prefix = historyIndex === -1 ? inputBuffer : savedInput;
+      if (historyIndex === -1) {
+        savedInput = inputBuffer;
+      }
+      var start = historyIndex === -1 ? commandHistory.length - 1 : historyIndex - 1;
+      for (var i = start; i >= 0; i--) {
+        if (!prefix || commandHistory[i].indexOf(prefix) === 0) {
+          historyIndex = i;
+          replaceLine(commandHistory[i]);
+          return;
+        }
+      }
+    }
+    function historyDown() {
+      if (historyIndex === -1) return;
+      var prefix = savedInput;
+      for (var i = historyIndex + 1; i < commandHistory.length; i++) {
+        if (!prefix || commandHistory[i].indexOf(prefix) === 0) {
+          historyIndex = i;
+          replaceLine(commandHistory[i]);
+          return;
+        }
+      }
+      historyIndex = -1;
+      replaceLine(savedInput);
+    }
+    function tabComplete() {
+      var input = inputBuffer.slice(0, cursorPos);
+      var parts = input.split(/\s+/);
+      var partial = parts[parts.length - 1] || "";
+      var candidates;
+      if (parts.length === 1 && !partial) {
+        try {
+          var cwdEntries = fs.readdirSync(cwd);
+          candidates = [];
+          for (var ce = 0; ce < cwdEntries.length; ce++) {
+            var ent = cwdEntries[ce];
+            if (typeof ent !== "string") continue;
+            var ep = path.join(cwd, ent);
+            try {
+              var est = fs.statSync(ep);
+              candidates.push(est.isDirectory() ? ent + "/" : ent);
+            } catch (e4) {
+              candidates.push(ent);
+            }
+          }
+        } catch (e5) {
+          candidates = [];
+        }
+      } else if (parts.length === 1) {
+        var cmdNames = Object.keys(commands).concat(["cd", "export", "exit", "set", "unset", "read", "source"]);
+        candidates = cmdNames.filter(function(c2) {
+          return c2.indexOf(partial) === 0;
+        });
+      } else {
+        var lastSlash = partial.lastIndexOf("/");
+        var dir = lastSlash >= 0 ? partial.slice(0, lastSlash + 1) : ".";
+        var prefix = lastSlash >= 0 ? partial.slice(lastSlash + 1) : partial;
+        var dirPath = dir.startsWith("/") ? dir : path.join(cwd, dir);
+        try {
+          var entries = fs.readdirSync(dirPath);
+          candidates = [];
+          for (var ei = 0; ei < entries.length; ei++) {
+            if (typeof entries[ei] === "string" && entries[ei].indexOf(prefix) === 0) {
+              candidates.push((lastSlash >= 0 ? partial.slice(0, lastSlash + 1) : "") + entries[ei]);
+            }
+          }
+        } catch (e) {
+          candidates = [];
+        }
+      }
+      if (candidates.length === 1) {
+        var completed = candidates[0];
+        if (parts.length > 1 && !completed.endsWith("/")) {
+          var checkPath = completed.startsWith("/") ? completed : path.join(cwd, completed);
+          try {
+            var st = fs.statSync(checkPath);
+            if (st.isDirectory()) completed += "/";
+          } catch (e2) {
+          }
+        }
+        var completion = completed.slice(partial.length);
+        inputBuffer = inputBuffer.slice(0, cursorPos) + completion + inputBuffer.slice(cursorPos);
+        cursorPos += completion.length;
+        process.stdout.write(completion);
+      } else if (candidates.length > 1) {
+        var displayCandidates = [];
+        for (var di = 0; di < candidates.length; di++) {
+          var c = candidates[di];
+          if (parts.length > 1 && !c.endsWith("/")) {
+            var cp2 = c.startsWith("/") ? c : path.join(cwd, c);
+            try {
+              var dst = fs.statSync(cp2);
+              if (dst.isDirectory()) c += "/";
+            } catch (e3) {
+            }
+          }
+          displayCandidates.push(c);
+        }
+        displayCandidates.sort();
+        completionMenu = {
+          candidates: displayCandidates,
+          selectedIndex: 0,
+          originalInput: inputBuffer,
+          originalCursorPos: cursorPos,
+          partial
+        };
+        menuSelect(0);
+        renderMenu();
+      }
+    }
+    function menuSelect(index) {
+      if (!completionMenu) return;
+      completionMenu.selectedIndex = index;
+      var candidate = completionMenu.candidates[index];
+      var partial = completionMenu.partial;
+      var origInput = completionMenu.originalInput;
+      var origCursor = completionMenu.originalCursorPos;
+      var before = origInput.slice(0, origCursor - partial.length);
+      var after = origInput.slice(origCursor);
+      replaceLine(before + candidate + after);
+    }
+    function renderMenu() {
+      if (!completionMenu) return;
+      var cands = completionMenu.candidates;
+      var sel = completionMenu.selectedIndex;
+      var maxShow = 10;
+      var start = Math.max(0, Math.min(sel - Math.floor(maxShow / 2), cands.length - maxShow));
+      var end = Math.min(cands.length, start + maxShow);
+      var line = "";
+      for (var ri = start; ri < end; ri++) {
+        if (ri > start) line += "  ";
+        if (ri === sel) {
+          line += "\x1B[7m" + cands[ri] + "\x1B[0m";
+        } else {
+          line += cands[ri];
+        }
+      }
+      if (start > 0) line = "... " + line;
+      if (end < cands.length) line += "  ... +" + (cands.length - end) + " more";
+      process.stdout.write("\x1B[s");
+      process.stdout.write("\n" + line + "\x1B[K");
+      process.stdout.write("\x1B[u");
+      menuVisible = true;
+    }
+    function exitMenu() {
+      if (!completionMenu) return;
+      if (menuVisible) {
+        process.stdout.write("\x1B[s\n\x1B[J\x1B[u");
+        menuVisible = false;
+      }
+      completionMenu = null;
+    }
+    function cancelMenu() {
+      if (!completionMenu) return;
+      replaceLine(completionMenu.originalInput);
+      cursorPos = completionMenu.originalCursorPos;
+      exitMenu();
+    }
+    if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+    process.stdin._keepAlive = true;
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    var _keepAlive = setInterval(function() {
+    }, 500);
+    var SILENT_PREFIX = "\0@machina/silent\0";
+    process.stdin.on("data", function(chunk) {
+      if (typeof chunk === "string" && chunk.length >= SILENT_PREFIX.length && chunk.indexOf(SILENT_PREFIX) === 0) {
+        var savedAsyncRunning = asyncRunning;
+        var savedExitCode = exitCode;
+        try {
+          var silentBody = chunk.slice(SILENT_PREFIX.length);
+          var silentLines = silentBody.split("\n");
+          for (var sli = 0; sli < silentLines.length; sli++) {
+            var sl = silentLines[sli];
+            if (sl.length > 0) {
+              try {
+                executeCommand(sl, false);
+              } catch (e) {
+              }
+            }
+          }
+        } finally {
+          asyncRunning = savedAsyncRunning;
+          exitCode = savedExitCode;
+        }
+        return;
+      }
+      for (var ci = 0; ci < chunk.length; ci++) {
+        var ch = chunk[ci];
+        if (completionMenu) {
+          if (ch === "\x1B" && ci + 1 < chunk.length && chunk[ci + 1] === "[") {
+            ci += 2;
+            while (ci < chunk.length && !/[A-Za-z~]/.test(chunk[ci])) {
+              ci++;
+            }
+            var mseq = chunk[ci];
+            if (mseq === "B" || mseq === "C") {
+              menuSelect((completionMenu.selectedIndex + 1) % completionMenu.candidates.length);
+              renderMenu();
+            } else if (mseq === "A" || mseq === "D") {
+              var mlen = completionMenu.candidates.length;
+              menuSelect((completionMenu.selectedIndex - 1 + mlen) % mlen);
+              renderMenu();
+            }
+            continue;
+          }
+          if (ch === "	") {
+            menuSelect((completionMenu.selectedIndex + 1) % completionMenu.candidates.length);
+            renderMenu();
+            continue;
+          }
+          if (ch === "\r" || ch === "\n") {
+            exitMenu();
+            continue;
+          }
+          if (ch === "\x1B") {
+            cancelMenu();
+            continue;
+          }
+          if (ch === "") {
+            cancelMenu();
+          } else {
+            exitMenu();
+          }
+        }
+        if (ch === "\x1B" && ci + 1 < chunk.length && chunk[ci + 1] === "[") {
+          ci += 2;
+          var param = "";
+          while (ci < chunk.length && !/[A-Za-z~]/.test(chunk[ci])) {
+            param += chunk[ci];
+            ci++;
+          }
+          var seq2 = chunk[ci];
+          var hasAlt = param === "1;3";
+          if (seq2 === "D" && hasAlt) {
+            wordLeft();
+          } else if (seq2 === "C" && hasAlt) {
+            wordRight();
+          } else if (seq2 === "D" && cursorPos > 0) {
+            var lw = charWidth(inputBuffer[cursorPos - 1]);
+            cursorPos--;
+            process.stdout.write("\x1B[" + lw + "D");
+          } else if (seq2 === "C" && cursorPos < inputBuffer.length) {
+            var rw = charWidth(inputBuffer[cursorPos]);
+            cursorPos++;
+            process.stdout.write("\x1B[" + rw + "C");
+          } else if (seq2 === "A") {
+            historyUp();
+          } else if (seq2 === "B") {
+            historyDown();
+          }
+          continue;
+        }
+        if (ch === "\x1B" && ci + 1 < chunk.length && chunk[ci + 1] === "\x7F") {
+          ci++;
+          deleteWordBack();
+          continue;
+        }
+        if (ch === "\r" || ch === "\n") {
+          process.stdout.write("\n");
+          if (inputBuffer.trim()) {
+            commandHistory.push(inputBuffer);
+          }
+          historyIndex = -1;
+          savedInput = "";
+          inputBuffer += "\n";
+          cursorPos = 0;
+        } else if (ch === "\x7F" || ch === "\b") {
+          if (cursorPos > 0) {
+            var deleted = inputBuffer[cursorPos - 1];
+            var dw = charWidth(deleted);
+            inputBuffer = inputBuffer.slice(0, cursorPos - 1) + inputBuffer.slice(cursorPos);
+            cursorPos--;
+            var t = inputBuffer.slice(cursorPos);
+            var tw = strWidth(t);
+            process.stdout.write("\x1B[" + dw + "D" + t + " ".repeat(dw) + "\x1B[" + (tw + dw) + "D");
+          }
+        } else if (ch === "") {
+          if (inputBuffer.length === 0) {
+            process.stdout.write("\n");
+            process.exit(0);
+          }
+        } else if (ch === "") {
+          inputBuffer = "";
+          cursorPos = 0;
+          process.stdout.write("^C\n");
+          prompt();
+        } else if (ch === "
") {
+          if (cursorPos > 0) {
+            process.stdout.write("\x1B[" + strWidth(inputBuffer.slice(0, cursorPos)) + "D");
+            cursorPos = 0;
+          }
+        } else if (ch === "") {
+          if (cursorPos < inputBuffer.length) {
+            process.stdout.write("\x1B[" + strWidth(inputBuffer.slice(cursorPos)) + "C");
+            cursorPos = inputBuffer.length;
+          }
+        } else if (ch === "") {
+          var uDel = inputBuffer.slice(0, cursorPos);
+          if (uDel.length > 0) {
+            var uDelW = strWidth(uDel);
+            inputBuffer = inputBuffer.slice(cursorPos);
+            process.stdout.write("\x1B[" + uDelW + "D" + inputBuffer + " ".repeat(uDelW) + "\x1B[" + (strWidth(inputBuffer) + uDelW) + "D");
+            cursorPos = 0;
+          }
+        } else if (ch === "\v") {
+          var kDel = inputBuffer.slice(cursorPos);
+          if (kDel.length > 0) {
+            inputBuffer = inputBuffer.slice(0, cursorPos);
+            process.stdout.write(" ".repeat(strWidth(kDel)) + "\x1B[" + strWidth(kDel) + "D");
+          }
+        } else if (ch === "") {
+          deleteWordBack();
+        } else if (ch === "	") {
+          tabComplete();
+        } else if (ch === "\x1B") {
+        } else {
+          inputBuffer = inputBuffer.slice(0, cursorPos) + ch + inputBuffer.slice(cursorPos);
+          cursorPos++;
+          var t2 = inputBuffer.slice(cursorPos);
+          process.stdout.write(ch + t2);
+          var tw2 = strWidth(t2);
+          if (tw2 > 0) {
+            process.stdout.write("\x1B[" + tw2 + "D");
+          }
+        }
+      }
+      processInputBuffer();
+    });
+    function processInputBuffer() {
+      if (asyncRunning) return;
+      var newlineIdx;
+      while (!asyncRunning && (newlineIdx = inputBuffer.indexOf("\n")) !== -1) {
+        var line = inputBuffer.substring(0, newlineIdx);
+        inputBuffer = inputBuffer.substring(newlineIdx + 1);
+        var bg = parseBg.parseTrailingBg(line);
+        asyncRunning = true;
+        var result = executeCommand(bg.command, bg.bgMode);
+        if (result === -1) {
+        } else {
+          asyncRunning = false;
+          prompt();
+        }
+      }
+    }
+    var rcFiles = rcLoaderModule.listRcFiles({ env, fs, path });
+    for (rcIdx = 0; rcIdx < rcFiles.length; rcIdx++) {
+      builtinSource([rcFiles[rcIdx]]);
+    }
+    var rcIdx;
+    prompt();
+  }
+});
+
+// packages/@machina.at/xsh/src/main.ts
+require_sh();