buninu 0.4.18 → 0.4.20

package/apps/bunmsh/src/fancy-ls.js

@@ -43,8 +43,8 @@ function classifySuffix(stats) {
 }
 
 function displayEntry(entry, options) {
-  const suffix = options.classify ? classifySuffix(entry.stats) : entry.stats.isDirectory() ? "/" : "";
-  return `${iconFor(entry.name, entry.stats, entry.path)} ${entry.name}${suffix}`;
+  const suffix = options.classify ? classifySuffix(entry.stats) : !options.plain && entry.stats.isDirectory() ? "/" : "";
+  return `${options.inode ? `${entry.stats.ino} ` : ""}${options.plain ? "" : `${iconFor(entry.name, entry.stats, entry.path)} `}${entry.name}${suffix}`;
 }
 
 function columns(items, width) {
@@ -98,7 +98,7 @@ function listDirectory(path, options) {
     .filter((entry) => options.all || options.almostAll || !entry.name.startsWith("."))
     .map((entry) => {
       const entryPath = resolve(path, entry.name);
-      return { name: entry.name, stats: lstatSync(entryPath), path: entryPath };
+      return { name: entry.name, stats: options.dereference ? statSync(entryPath) : lstatSync(entryPath), path: entryPath };
     });
   if (options.all) entries = [
     { name: ".", stats: lstatSync(path), path },
@@ -116,6 +116,7 @@ function listDirectory(path, options) {
 
 export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
   const options = {
+    plain: argv[0] === "ls" && Boolean(state.shellOptions?.posix),
     all: false, almostAll: false, directory: false, long: false, human: false,
     recursive: false, time: false, reverse: false, size: false, one: false, classify: false,
   };
@@ -128,6 +129,8 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
       for (const flag of argument.slice(1)) {
         if (flag === "a") options.all = true;
         else if (flag === "A") options.almostAll = true;
+        else if (flag === "L") options.dereference = true;
+        else if (flag === "i") options.inode = true;
         else if (flag === "d") options.directory = true;
         else if (flag === "l") options.long = true;
         else if (flag === "h") options.human = true;
@@ -148,7 +151,7 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
   const show = (operand, heading = operands.length > 1, separate = true) => {
     const path = isAbsolute(operand) ? operand : resolve(state.cwd, operand);
     try {
-      const stats = lstatSync(path);
+      const stats = options.dereference ? statSync(path) : lstatSync(path);
       let listingDirectory = stats.isDirectory() && !options.directory;
       // GNU/POSIX-style ls follows a command-line symlink to a directory for
       // an ordinary listing and for -R. -d, -l, and -F request information
@@ -196,6 +199,14 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
       stderr += `bunmsh: ${argv[0]}: ${operand}: ${error.message}\n`;
     }
   };
+  if (options.time || options.size) operands.sort((a,b) => {
+    try {
+      const stat = options.dereference ? statSync : lstatSync;
+      const left=stat(resolve(state.cwd,a)), right=stat(resolve(state.cwd,b));
+      const order=(options.size ? right.size-left.size : right.mtimeMs-left.mtimeMs) || a.localeCompare(b);
+      return options.reverse ? -order : order;
+    } catch { return 0; }
+  });
   for (const operand of operands) show(operand);
   return { status, stdout, stderr };
 }

package/apps/bunmsh/src/main.js

@@ -6,6 +6,7 @@ import {
   createState,
   execute,
   executeArgv,
+  finishShell,
   executeBunShellFallback,
   isJavaScriptMode,
   needsMoreInput,
@@ -440,6 +441,10 @@ async function interactive(state) {
     }
   };
   const interrupt = () => {
+    if (Object.hasOwn(state.traps,"SIGINT")) {
+      if (state.traps.SIGINT && !state.pendingTraps.includes("SIGINT")) state.pendingTraps.push("SIGINT");
+      return;
+    }
     state.lastStatus = 130;
     if (foregroundCommand || promptAbort?.signal.aborted) return;
     process.stdout.write("\n");
@@ -456,6 +461,7 @@ async function interactive(state) {
   // periodic autosave.
   const SIGNAL_EXIT_STATUS = { SIGHUP: 129, SIGTERM: 143 };
   const terminate = (signal) => {
+    if (Object.hasOwn(state.traps,signal)) return;
     state.exitRequested = true;
     state.exitStatus = SIGNAL_EXIT_STATUS[signal] ?? state.exitStatus;
     if (foregroundCommand) {
@@ -725,7 +731,7 @@ async function interactive(state) {
     process.off("SIGHUP", terminate);
     readline.close();
   }
-  return state.exitRequested ? state.exitStatus : state.lastStatus;
+  return (await finishShell(state,state.exitRequested ? state.exitStatus : state.lastStatus)).status;
 }
 
 async function main(argv) {
@@ -736,6 +742,7 @@ async function main(argv) {
   let forceInteractive = false;
   let forceMouse = false;
   let builtinOnly = false;
+  const shellOptions = {};
   let i = 0;
   for (; i < argv.length; i++) {
     const arg = argv[i];
@@ -785,6 +792,10 @@ async function main(argv) {
       await printChangelog();
       return 0;
     }
+    if (/^-[eufxv]+$/.test(arg)) {
+      for (const key of arg.slice(1)) shellOptions[key]=true;
+      continue;
+    }
     if (arg.startsWith("-")) {
       console.error(`bunmsh: ${arg}: unknown option`);
       return 2;
@@ -801,18 +812,22 @@ async function main(argv) {
     if (forceMouse) state.mouseTracking = true;
     if (builtinOnly) state.pathSearch = false;
     const result = await executeArgv(forwardedArgv, state);
-    return state.exitRequested ? state.exitStatus : result.status;
+    return (await finishShell(state,state.exitRequested ? state.exitStatus : result.status)).status;
   }
 
   if (command !== null) {
     const name = argv[i] ?? "bunmsh";
-    const state = createState({
-      args: [name, ...argv.slice(i + 1)],
-      mouseTracking: forceMouse || undefined,
-      pathSearch: builtinOnly ? false : undefined,
-    });
+    const state = process.env.BUNMSH_INTERNAL_PIPELINE_STATE
+      ? pipelineChildState()
+      : createState({
+          args: [name, ...argv.slice(i + 1)],
+          mouseTracking: forceMouse || undefined,
+          pathSearch: builtinOnly ? false : undefined,
+        });
+    Object.assign(state.shellOptions,shellOptions);
+    if (state.shellOptions.v) console.error(command);
     const result = await execute(command, state);
-    return state.exitRequested ? state.exitStatus : result.status;
+    return (await finishShell(state,state.exitRequested ? state.exitStatus : result.status)).status;
   }
 
   if (i < argv.length) {
@@ -824,9 +839,11 @@ async function main(argv) {
         mouseTracking: forceMouse || undefined,
         pathSearch: builtinOnly ? false : undefined,
       });
+      Object.assign(state.shellOptions,shellOptions);
+      if (state.shellOptions.v) console.error(source);
       const result = await execute(source, state);
       if (forceInteractive && !state.exitRequested) return interactive(state);
-      return state.exitRequested ? state.exitStatus : result.status;
+      return (await finishShell(state,state.exitRequested ? state.exitStatus : result.status)).status;
     } catch (error) {
       console.error(`bunmsh: ${script}: ${error.message}`);
       return 1;
@@ -837,10 +854,11 @@ async function main(argv) {
     mouseTracking: forceMouse || undefined,
     pathSearch: builtinOnly ? false : undefined,
   });
+  Object.assign(state.shellOptions,shellOptions);
   if (forceInteractive || process.stdin.isTTY) return interactive(state);
   const source = await Bun.stdin.text();
   const result = await execute(source, state);
-  return state.exitRequested ? state.exitStatus : result.status;
+  return (await finishShell(state,state.exitRequested ? state.exitStatus : result.status)).status;
 }
 
 // Lets --define process.env.SERVE_AUTO_OPEN=/index.html, =off, or =yes

package/apps/bunmsh/src/sed.js

@@ -0,0 +1,159 @@
+// The fallback operates on pattern/hold spaces, with a program counter for
+// branches. Parsing delimiters before command separators preserves s/;/x/.
+export function compileSed(script, regexSource) {
+  let i = 0, lastPattern = null;
+  const commands = [], groups = [], labels = new Map();
+  const space = () => { while (/[ \t\r]/.test(script[i] ?? "") && i < script.length) i++; };
+  const field = delimiter => {
+    let value = "";
+    for (; i < script.length; i++) {
+      const ch = script[i];
+      if (ch === delimiter) { i++; return value; }
+      if (ch === "\\" && i + 1 < script.length) {
+        const next = script[++i];
+        value += next === delimiter && !'.*[]^$\\'.includes(next) ? next : `\\${next}`;
+      } else value += ch;
+    }
+    throw new Error("unterminated sed field");
+  };
+  const regex = pattern => {
+    if (pattern) lastPattern = pattern;
+    if (lastPattern === null) throw new Error("no previous regular expression");
+    return regexSource(lastPattern);
+  };
+  const address = () => {
+    if (script[i] === "$") { i++; return {last:true}; }
+    if (/\d/.test(script[i] ?? "")) { const match = /^\d+/.exec(script.slice(i))[0]; i += match.length; return {line:Number(match)}; }
+    if (script[i] === "/") { i++; return {regex:new RegExp(regex(field("/")))}; }
+    return null;
+  };
+  while (i < script.length) {
+    space();
+    if (";\n".includes(script[i])) { i++; continue; }
+    if (script[i] === "#") { while (i < script.length && script[i] !== "\n") i++; continue; }
+    if (i >= script.length) break;
+    const first = address(); space();
+    let second = null;
+    if (script[i] === ",") { i++; space(); second = address(); if (!second) throw new Error("missing range address"); }
+    space(); const invert = script[i] === "!"; if (invert) { i++; space(); }
+    const op = script[i++], command = {op, first, second, invert};
+    const index = commands.length;
+    if (op === "{") groups.push(index);
+    else if (op === "}") { const open = groups.pop(); if (open === undefined) throw new Error("unexpected }"); commands[open].end = index; }
+    else if (op === "s" || op === "y") {
+      const delimiter = script[i++];
+      const pattern = field(delimiter), replacement = field(delimiter);
+      if (op === "y") {
+        const unescape = s => s.replace(/\\n/g,"\n").replace(/\\(.)/g,"$1");
+        command.from = unescape(pattern); command.to = unescape(replacement);
+        if (command.from.length !== command.to.length) throw new Error("unequal y strings");
+      } else {
+        const flags = /^[gp0-9]*/.exec(script.slice(i))[0]; i += flags.length;
+        command.regex = new RegExp(regex(pattern), "g");
+        command.replacement = replacement;
+        command.global = flags.includes("g"); command.print = flags.includes("p");
+        command.occurrence = Number(/\d+/.exec(flags)?.[0] ?? 1);
+      }
+    } else if ([":","b","t","T"].includes(op)) {
+      space(); const start = i; while (i < script.length && !";\n}".includes(script[i])) i++;
+      command.label = script.slice(start,i).trim();
+      if (op === ":") labels.set(command.label,index);
+    } else if (op === "r") {
+      space(); const start=i; while (i<script.length && script[i]!=="\n") i++;
+      command.file=script.slice(start,i);
+      if (!command.file) throw new Error("r requires a filename");
+    } else if (["a","i","c"].includes(op)) {
+      space(); if (script[i] === "\\") { i++; if (script[i] === "\n") i++; }
+      let text = "";
+      while (i < script.length && script[i] !== "\n") {
+        if (script[i] === "\\" && script[i+1] === "\n") { text += "\n"; i+=2; }
+        else text += script[i++];
+      }
+      command.text = text;
+    } else if (!"pPdDqnhHgGxN=".includes(op ?? "")) throw new Error(`unsupported sed command: ${op}`);
+    commands.push(command);
+  }
+  if (groups.length) throw new Error("unclosed sed group");
+  for (const command of commands) if (["b","t","T"].includes(command.op)) {
+    command.target = command.label ? labels.get(command.label) : commands.length;
+    if (command.target === undefined) throw new Error(`undefined sed label: ${command.label}`);
+  }
+  return commands;
+}
+
+function replacementText(template, args) {
+  let output = "";
+  for (let i = 0; i < template.length; i++) {
+    if (template[i] === "&") output += args[0];
+    else if (template[i] === "\\" && i + 1 < template.length) {
+      const ch = template[++i];
+      output += /[1-9]/.test(ch) ? (args[Number(ch)] ?? "") : ch === "n" ? "\n" : ch;
+    } else output += template[i];
+  }
+  return output;
+}
+
+export function applySed(text, commands, quiet, readFile = () => "") {
+  if (!text) return "";
+  const trailing = text.endsWith("\n"), lines = text.split("\n");
+  if (trailing) lines.pop();
+  const active = new Set(), output = [];
+  let hold = "";
+  for (let index = 0; index < lines.length; index++) {
+    let pattern = lines[index], deleted = false, changed = false, quit = false;
+    const appended = [];
+    const emit = value => output.push(value + (index < lines.length-1 || trailing ? "\n" : ""));
+    const matches = a => a.last ? index === lines.length-1 : a.line !== undefined ? index+1 === a.line : a.regex.test(pattern);
+    for (let pc = 0; pc < commands.length; pc++) {
+      const c = commands[pc];
+      let selected = !c.first || matches(c.first);
+      if (c.second) {
+        const wasActive = active.has(pc);
+        selected ||= wasActive;
+        if (selected) {
+          active.add(pc);
+          if ((wasActive || !c.second.regex) && (c.second.line !== undefined ? index+1 >= c.second.line : matches(c.second))) active.delete(pc);
+        }
+      }
+      if (c.invert) selected = !selected;
+      if (!selected) { if (c.op === "{") pc = c.end; continue; }
+      if (c.op === "s") {
+        let count = 0, replaced = false;
+        pattern = pattern.replace(c.regex,(...args) => {
+          count++;
+          if (count !== c.occurrence && !(c.global && count >= c.occurrence)) return args[0];
+          replaced = true; return replacementText(c.replacement,args);
+        });
+        changed ||= replaced;
+        if (replaced && c.print) emit(pattern);
+      } else if (c.op === "y") pattern = [...pattern].map(ch => { const at=c.from.indexOf(ch); return at<0 ? ch : c.to[at]; }).join("");
+      else if (c.op === "p") emit(pattern);
+      else if (c.op === "P") emit(pattern.split("\n")[0]);
+      else if (c.op === "=") emit(String(index+1));
+      else if (c.op === "h") hold = pattern;
+      else if (c.op === "H") hold += "\n" + pattern;
+      else if (c.op === "g") pattern = hold;
+      else if (c.op === "G") pattern += "\n" + hold;
+      else if (c.op === "x") [pattern,hold] = [hold,pattern];
+      else if (c.op === "d") { deleted=true; break; }
+      else if (c.op === "D") { const nl=pattern.indexOf("\n"); if (nl<0) { deleted=true; break; } pattern=pattern.slice(nl+1); pc=-1; }
+      else if (c.op === "q") { quit=true; break; }
+      else if (c.op === "n" || c.op === "N") {
+        if (c.op === "n" && !quiet) emit(pattern);
+        if (index+1 >= lines.length) { deleted = c.op === "n"; quit=true; break; }
+        pattern = (c.op === "N" ? pattern + "\n" : "") + lines[++index]; changed=false;
+      } else if (["b","t","T"].includes(c.op)) {
+        const take = c.op === "b" || (c.op === "t" ? changed : !changed);
+        if (c.op !== "b") changed=false;
+        if (take) pc=c.target-1;
+      } else if (c.op === "r") appended.push(readFile(c.file));
+      else if (c.op === "a") appended.push(c.text+"\n");
+      else if (c.op === "i") output.push(c.text+"\n");
+      else if (c.op === "c") { if (!c.second || !active.has(pc)) output.push(c.text+"\n"); deleted=true; break; }
+    }
+    if (!quiet && !deleted) emit(pattern);
+    output.push(...appended);
+    if (quit) break;
+  }
+  return output.join("");
+}