buninu 0.4.17 → 0.4.19

package/apps/bunmsh/test/reference.test.js

@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { chmodSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readlinkSync, readdirSync, rmSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createState, decode, execute } from "../src/shell.js";
@@ -86,6 +86,15 @@ async function expectBuiltinSedLike(args, input, cwd = root) {
   expect(actual).toEqual(reference);
 }
 
+async function expectBuiltinLikeSystem(name, args, input = "", cwd = root) {
+  const [actual, reference] = await Promise.all([
+    invokeArgvWithInput(
+      [process.execPath, join(root, "src/main.js"), "-cc", "builtin", name, ...args], input, cwd),
+    invokeArgvWithInput([Bun.which(name), ...args], input, cwd),
+  ]);
+  expect(actual).toEqual(reference);
+}
+
 describe("/bin/sh reference", () => {
   describe("quote and word expansion", () => {
     test("removes LF and CRLF backslash continuations before tokenization", async () => {
@@ -402,6 +411,79 @@ printf ':%s' $?
   });
 });
 
+describe("system multi-operand reference", () => {
+  test("printf repeats its format until all arguments are consumed", async () => {
+    await expectBuiltinLikeSystem("printf", ["%s=%d\n", "one", "1", "two", "2"]);
+    await expectBuiltinLikeSystem("printf", ["[%s][%s]\n", "one", "two", "three"]);
+  });
+
+  test("ln links each source into a target directory", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-ln-reference-"));
+    const actualDir = join(directory, "actual");
+    const systemDir = join(directory, "system");
+    try {
+      for (const cwd of [actualDir, systemDir]) {
+        mkdirSync(cwd);
+        mkdirSync(join(cwd, "hard"));
+        mkdirSync(join(cwd, "soft"));
+        await Bun.write(join(cwd, "one"), "first\n");
+        await Bun.write(join(cwd, "two"), "second\n");
+      }
+      for (const args of [["one", "two", "hard"], ["-s", "one", "two", "soft"]]) {
+        const [actual, reference] = await Promise.all([
+          invokeArgvWithInput([process.execPath, join(root, "src/main.js"), "-cc", "builtin", "ln", ...args], "", actualDir),
+          invokeArgvWithInput([Bun.which("ln"), ...args], "", systemDir),
+        ]);
+        expect(actual).toEqual(reference);
+      }
+      for (const name of ["one", "two"]) {
+        expect(readdirSync(join(actualDir, "hard"))).toEqual(readdirSync(join(systemDir, "hard")));
+        expect(statSync(join(actualDir, "hard", name)).ino).toBe(statSync(join(actualDir, name)).ino);
+        expect(readlinkSync(join(actualDir, "soft", name)))
+          .toBe(readlinkSync(join(systemDir, "soft", name)));
+      }
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
+
+  test("head and tail select lines independently from each file", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-parts-reference-"));
+    try {
+      await Bun.write(join(directory, "one"), "alpha\nbeta\n");
+      await Bun.write(join(directory, "two"), "gamma\ndelta\n");
+      for (const args of [["-n", "1", "one", "two"], ["-c", "2", "one", "two"],
+        ["-n", "0", "one", "two"]])
+        await expectBuiltinLikeSystem("head", args, "", directory);
+      for (const args of [["-n", "1", "one", "two"], ["-n", "+2", "one", "two"],
+        ["-n", "0", "one", "two"]])
+        await expectBuiltinLikeSystem("tail", args, "", directory);
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
+
+  test("wc prints each file count and a total; cut reads each file", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-text-reference-"));
+    try {
+      await Bun.write(join(directory, "one"), "alpha beta\ngamma\n");
+      await Bun.write(join(directory, "two"), "delta\nepsilon zeta\n");
+      for (const args of [["-l", "one", "two"], ["-lwc", "one", "two"]])
+        await expectBuiltinLikeSystem("wc", args, "", directory);
+      await expectBuiltinLikeSystem("cut", ["-c", "1-3", "one", "two"], "", directory);
+      await expectBuiltinLikeSystem("cut", ["-c", "1", "one"], "", directory);
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
+
+  test("md5sum and sha256sum hash each file separately", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-hash-reference-"));
+    try {
+      await Bun.write(join(directory, "one"), "alpha\n");
+      await Bun.write(join(directory, "two"), "beta\n");
+      for (const name of ["md5sum", "sha256sum"]) {
+        await expectBuiltinLikeSystem(name, ["one", "two"], "", directory);
+        await expectBuiltinLikeSystem(name, [], "stdin text\n", directory);
+      }
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
+});
+
 describe("system tail reference", () => {
   test("supports -n +N and compact -n+N from-start modes", async () => {
     const input = "one\ntwo\nthree\nfour\n";
@@ -450,6 +532,18 @@ describe("system grep reference", () => {
       await expectBuiltinGrepLike(["-n", "needle", "tree/a.txt", "tree/nested/b.txt"], "", directory);
     } finally { rmSync(directory, { recursive: true, force: true }); }
   });
+
+  test("searches the current directory for -r without a path", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-grep-cwd-reference-"));
+    try {
+      mkdirSync(join(directory, "nested"));
+      await Bun.write(join(directory, "nested", "a.txt"), "needle one\nnone\n");
+      await expectBuiltinGrepLike(["-r", "needle"], "", directory);
+      await expectBuiltinGrepLike(["-rn", "needle"], "", directory);
+      await expectBuiltinGrepLike(["-r", "missing"], "", directory);
+      await expectBuiltinGrepLike(["-rq", "needle"], "", directory);
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
 });
 
 describe("system sed reference", () => {

package/apps/bunmsh/test/shell1.test.js

@@ -93,6 +93,28 @@ describe("parser", () => {
     expect(parse("echo hi | tr a-z A-Z")[0].pipeline).toHaveLength(2);
   });
 
+  test("parses a trailing background operator", () => {
+    const [job] = parse("sleep 30 &");
+    expect(job.background).toBe(true);
+    expect(job.pipeline).toHaveLength(1);
+    const [foreground] = parse("echo before & after");
+    expect(foreground.background).toBe(false);
+    expect(foreground.pipeline[0].words[2].fragments[0].text).toBe("&");
+    expect(parse(`echo "&"`)[0].background).toBe(false);
+    expect(parse("echo \\&")[0].background).toBe(false);
+  });
+
+  test("recognizes a trailing & from tokens, independently of comments and redirect targets", () => {
+    for (const source of ["sleep 30 & # comment", "sleep 30 & # comment &", "sleep 30 &\r\n# comment\r\n"]) {
+      const [job] = parse(source);
+      expect(job.background).toBe(true);
+      expect(job.pipeline[0].words).toHaveLength(2);
+    }
+    for (const source of ["echo & > file&", "echo & <<< input&", "echo &; # comment &", "echo hi # &"]) {
+      expect(parse(source)[0].background).toBe(false);
+    }
+  });
+
   test("a bare trailing backslash asks for one more interactive line, then joins", () => {
     // This is what the interactive prompt loop's `pending` string looks like
     // the instant Enter is pressed after typing "echo hi \" -- the next
@@ -398,6 +420,69 @@ describe("execution", () => {
     });
   });
 
+  test("parses POSIX case clauses independently of physical lines", async () => {
+    expect(await run('case "a b" in a\\ b|no) echo escaped;; *) echo bad;; esac')).toMatchObject({
+      status: 0,
+      stdout: "escaped\n",
+      stderr: "",
+    });
+    expect(await run("case x in (no) echo bad ;; (x) echo parenthesized\nesac")).toMatchObject({
+      status: 0,
+      stdout: "parenthesized\n",
+      stderr: "",
+    });
+    expect(await run("case x in x) case y in y) echo nested;; esac ;; *) echo bad;; esac")).toMatchObject({
+      status: 0,
+      stdout: "nested\n",
+      stderr: "",
+    });
+    expect(await run("case outer in outer) case inner in inner) echo autoconf;; esac;; *) echo bad;; esac")).toMatchObject({
+      status: 0,
+      stdout: "autoconf\n",
+      stderr: "",
+    });
+    expect(await run("case x in x) echo case;; esac; echo after")).toMatchObject({
+      status: 0,
+      stdout: "case\nafter\n",
+      stderr: "",
+    });
+    expect(await run("case b in [!ac]) echo bracket;; *) echo bad;; esac; case '*' in '*') echo quoted;; esac")).toMatchObject({
+      stdout: "bracket\nquoted\n",
+    });
+  });
+
+  test("implements mksh case fall-through terminators", async () => {
+    expect(await run("case b in a) echo a ;& b) echo b ;& c) echo c ;; esac")).toMatchObject({
+      stdout: "b\nc\n",
+    });
+    expect(await run("case b in a) echo a ;| b) echo b ;| *) echo star ;; esac")).toMatchObject({
+      stdout: "b\nstar\n",
+    });
+  });
+
+  test("accepts POSIX for headers with do on the next line", async () => {
+    expect(await run("for value in one two\ndo\n echo $value\ndone")).toMatchObject({
+      status: 0,
+      stdout: "one\ntwo\n",
+      stderr: "",
+    });
+    expect(await run("set -- left right; for arg\ndo echo $arg; done")).toMatchObject({
+      status: 0,
+      stdout: "left\nright\n",
+      stderr: "",
+    });
+    expect(await run("set -- a b; for arg; do printf '<%s>\\n' \"$arg\"; done")).toMatchObject({
+      status: 0,
+      stdout: "<a>\n<b>\n",
+      stderr: "",
+    });
+    expect(await run("for value in; do echo bad; done; echo empty")).toMatchObject({
+      status: 0,
+      stdout: "empty\n",
+      stderr: "",
+    });
+  });
+
   test("provides basic fallback text and utility commands", async () => {
     expect(await run("printf 'c\\na\\nb\\n' | builtin sort")).toMatchObject({ stdout: "a\nb\nc\n" });
     expect(await run("printf 'one two\\nthree\\n' | builtin wc -lwc")).toMatchObject({ stdout: "2 3 14\n" });
@@ -911,6 +996,7 @@ fi
   test("expands variables while respecting single quotes", async () => {
     const output = await run(`X=world; print -r -- "hello $X"; print -r -- '$X'`);
     expect(output.stdout).toBe("hello world\n$X\n");
+    expect((await run("printf '%s\\n' \"literal\\`backtick\"")).stdout).toBe("literal`backtick\n");
   });
 
   test("supports status connectors", async () => {
@@ -926,6 +1012,75 @@ fi
     expect(output.status).toBe(0);
   });
 
+  test("returns immediately and exposes a background external process through Bun.sha.procs", async () => {
+    const previous = Bun.sha.procs;
+    Bun.sha.procs = [];
+    try {
+      const started = performance.now();
+      const output = await run(`${process.execPath} -e 'await Bun.sleep(30000)' &`);
+      const first = Bun.sha.procs.at(-1);
+      const secondOutput = await run(`${process.execPath} -e 'await Bun.sleep(30000)' &`);
+      const proc = Bun.sha.procs.at(-1);
+
+      expect(performance.now() - started).toBeLessThan(1000);
+      expect(output.status).toBe(0);
+      expect(output.stderr).toBe(`[1] ${first.pid} Bun.sha.procs[0]\n`);
+      expect(secondOutput.status).toBe(0);
+      expect(secondOutput.stderr).toBe(`[2] ${proc.pid} Bun.sha.procs[1]\n`);
+      expect(Bun.sha.procs).toHaveLength(2);
+      expect(proc).not.toBe(first);
+      expect(proc.pid).toBeGreaterThan(0);
+      expect(typeof proc.kill).toBe("function");
+      first.kill();
+      proc.kill();
+      await Promise.all([first.exited, proc.exited]);
+    } finally {
+      if (previous === undefined) delete Bun.sha.procs;
+      else Bun.sha.procs = previous;
+    }
+  });
+
+  test("keeps the minimal background form limited to one external command", async () => {
+    const builtin = await run("echo nope &");
+    const pipeline = await run("printf x | cat &");
+    expect(builtin.status).toBe(2);
+    expect(pipeline.status).toBe(2);
+    expect(builtin.stderr).toContain("only a single external command");
+    expect(pipeline.stderr).toContain("only a single external command");
+  });
+
+  test("rejects background redirects before expanding, opening files, or spawning", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-background-redirect-"));
+    const previousProcs = Bun.sha.procs;
+    const previousCount = previousProcs?.length;
+    try {
+      await Bun.write(join(directory, "input"), "input content\n");
+      await Bun.write(join(directory, "output"), "keep this content\n");
+      const command = `'${process.execPath.replaceAll("'", "'\\''")}' -e 'await Bun.write("spawned", "ran")'`;
+      const sources = [
+        ...["> output", ">> output", "2> output", "2>> output", "> new-output", "< input", "< missing-input", "<<< payload", "1>&2", "2>&1"]
+          .map((redirect) => `${command} ${redirect} & # comment`),
+        `${command} <<EOF &\nbody\nEOF\n`,
+        `${command} <<-EOF &\n\tbody\n\tEOF\n`,
+        `${command} > $(echo expanded > expanded-marker; echo output) &`,
+      ];
+      for (const source of sources) {
+        const output = await run(source, { cwd: directory });
+        expect(output.status).toBe(2);
+        expect(output.stdout).toBe("");
+        expect(output.stderr).toContain("without redirections");
+      }
+      expect(await Bun.file(join(directory, "output")).text()).toBe("keep this content\n");
+      expect(await Bun.file(join(directory, "input")).text()).toBe("input content\n");
+      for (const name of ["spawned", "new-output", "expanded-marker"])
+        expect(await Bun.file(join(directory, name)).exists()).toBe(false);
+      expect(Bun.sha.procs).toBe(previousProcs);
+      expect(Bun.sha.procs?.length).toBe(previousCount);
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
   test("keeps builtin state outside pipelines", async () => {
     const output = await run("export BUNMSH_TEST=value; print -r -- $BUNMSH_TEST");
     expect(output.stdout).toBe("value\n");

package/apps/jsgotty/LICENSES/MIT-microsoft-terminal-conpty.txt

@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/apps/jsgotty/LICENSES/MIT-ws.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+Copyright (c) 2013 Arnout Kazemier and contributors
+Copyright (c) 2016 Luigi Pinca and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.