buninu 0.4.0 → 0.4.2

package/apps/bunmsh/test/shell.test.js

@@ -8,21 +8,35 @@ import {
   createState,
   decode,
   execute,
+  colorProcessCommand,
+  colorProcessTable,
+  highlightShellCommand,
   executeArgv,
+  formatProcessTable,
+  isJavaScriptMode,
   needsMoreInput,
   parse,
+  parsePosixProcessList,
+  parseWindowsProcessList,
   runUnameFallback,
+  SH_COLORS,
+  taskkillFailure,
   tokenize,
+  windowsKillCommand,
 } from "../src/shell.js";
 import {
   CommandIndex,
   FileIndex,
+  VariableIndex,
   completionContext,
   fitGhost,
   firstPrefixMatch,
   historyGhost,
+  javascriptContext,
   nextGhostChunk,
   prefixMatches,
+  variableCompletion,
+  variableContext,
 } from "../src/completion.js";
 import {
   bunmshHistoryPath,
@@ -373,7 +387,7 @@ describe("execution", () => {
     const files = { ":": "colon", ...titles };
     const optionDocs = new Set([
       "basename", "builtin", "bun", "bunmsh", "cat", "catfancy", "chmod", "command", "cp", "cut",
-      "date", "dirname", "echo", "env", "find", "getopts", "grep", "head", "kill",
+      "curl", "date", "dirname", "echo", "env", "find", "getopts", "grep", "head", "kill",
       "ln", "ls", "lsbun", "lsfancy", "mkdir", "mktemp", "mv", "print", "printf",
       "read", "readonly", "rm", "rmdir", "sed", "seq", "serve", "set", "sleep",
       "sort", "tab", "tac", "tail", "tee", "test", "touch", "tr", "unalias",
@@ -772,9 +786,10 @@ fi
 
   test("provides color aliases for common commands", () => {
     const state = createState();
+    // toybox diff takes a bare --color; it has no =auto form.
     expect(state.aliases).toEqual({
       ls: ["ls", "--color=auto"],
-      diff: ["diff", "--color=auto"],
+      diff: ["diff", "--color"],
       grep: ["grep", "--color=auto"],
     });
   });
@@ -1776,3 +1791,302 @@ describe("CLI", () => {
     expect(transcript).not.toContain(MOUSE_ON);
   });
 });
+
+describe("pspa", () => {
+  test("lists every PID with its full command line", async () => {
+    const execution = await executeArgv(["builtin", "pspa"], createState(), { capture: true });
+    expect(execution.status).toBe(0);
+    const lines = decode(execution.stdout).split("\n");
+    //  POSIX passes `ps -eo pid,args` through untouched, so its header is the
+    //  header, and this test process has to be in the listing under itself.
+    expect(lines[0]).toMatch(/^\s*PID COMMAND$/);
+    const own = lines.find((line) => new RegExp(`^\\s*${process.pid} `).test(line));
+    expect(own).toBeDefined();
+    expect(own.length).toBeGreaterThan(String(process.pid).length + 1);
+  });
+
+  test("takes no operands", async () => {
+    const execution = await executeArgv(["builtin", "pspa", "extra"], createState(), { capture: true });
+    expect(execution.status).toBe(2);
+    expect(decode(execution.stderr)).toBe("bunmsh: pspa: unexpected operand: extra\n");
+  });
+
+  test("parses the Windows Win32_Process listing into sorted rows", () => {
+    //  What the PowerShell one-liner writes: PID, a space, then the command
+    //  line — or the image name when a system process has none.
+    const rows = parseWindowsProcessList(
+      "4 System\r\n" +
+      "9876 \"C:\\Program Files\\App\\app.exe\" --flag \"a b\"\r\n" +
+      "1200 C:\\Windows\\system32\\svchost.exe -k netsvcs\r\n" +
+      "\r\n",
+    );
+    expect(rows).toEqual([
+      { pid: 4, args: "System" },
+      { pid: 1200, args: "C:\\Windows\\system32\\svchost.exe -k netsvcs" },
+      { pid: 9876, args: '"C:\\Program Files\\App\\app.exe" --flag "a b"' },
+    ]);
+  });
+
+  test("drops the continuation lines a multi-line command line produces", () => {
+    expect(parseWindowsProcessList("42 one\nwrapped continuation\n88 two\n")).toEqual([
+      { pid: 42, args: "one" },
+      { pid: 88, args: "two" },
+    ]);
+  });
+
+  test("formats the Windows rows into the same two columns ps prints", () => {
+    expect(formatProcessTable([{ pid: 4, args: "System" }, { pid: 1200, args: "svchost.exe" }]))
+      .toBe("  PID COMMAND\n    4 System\n 1200 svchost.exe\n");
+    //  The column widens past procps' five columns for a longer PID.
+    expect(formatProcessTable([{ pid: 123456, args: "app.exe" }]))
+      .toBe("   PID COMMAND\n123456 app.exe\n");
+    expect(formatProcessTable([])).toBe("  PID COMMAND\n");
+  });
+});
+
+describe("kill", () => {
+  test("probes with signal 0 and reports an unknown pid", async () => {
+    expect(await executeArgv(["builtin", "kill", "-0", String(process.pid)], createState(), { capture: true }))
+      .toMatchObject({ status: 0 });
+    const missing = await executeArgv(["builtin", "kill", "-0", "999999"], createState(), { capture: true });
+    expect(missing.status).toBe(1);
+    expect(decode(missing.stderr)).toContain("bunmsh: kill: 999999:");
+    expect(await executeArgv(["builtin", "kill"], createState(), { capture: true }))
+      .toMatchObject({ status: 2 });
+  });
+
+  test.skipIf(process.platform === "win32")("signals a real process", async () => {
+    const proc = Bun.spawn({ cmd: ["sleep", "30"], stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+    try {
+      expect(await executeArgv(["builtin", "kill", String(proc.pid)], createState(), { capture: true }))
+        .toMatchObject({ status: 0 });
+      await proc.exited;
+      expect(proc.signalCode).toBe("SIGTERM");
+    } finally { proc.kill("SIGKILL"); }
+  });
+
+  test("builds the taskkill command a Windows kill goes through", () => {
+    //  /T reaches the children libuv's TerminateProcess leaves running, /F is
+    //  what makes it work on a console process with no message loop.
+    expect(windowsKillCommand(1234)).toEqual(["taskkill", "/PID", "1234", "/T", "/F"]);
+    expect(windowsKillCommand("1234")).toEqual(["taskkill", "/PID", "1234", "/T", "/F"]);
+  });
+
+  test("rewrites a taskkill failure as one of our own lines", () => {
+    expect(taskkillFailure(0, "SUCCESS: The process with PID 1234 has been terminated.\r\n", ""))
+      .toBeNull();
+    expect(taskkillFailure(128, "", 'ERROR: The process "1234" not found.\r\n'))
+      .toBe('The process "1234" not found.');
+    expect(taskkillFailure(1, "ERROR: Access is denied.\r\n", "")).toBe("Access is denied.");
+    expect(taskkillFailure(1, "", "")).toBe("taskkill exited with status 1");
+  });
+});
+
+describe("pspac", () => {
+  const wrap = (name, value) => `${SH_COLORS[name]}${value}${SH_COLORS.reset}`;
+
+  test("reads the rows back out of the plain ps listing", () => {
+    expect(parsePosixProcessList("  PID COMMAND\n    1 /init\n12771 bash -l\n\n")).toEqual([
+      { pid: 1, args: "/init" },
+      { pid: 12771, args: "bash -l" },
+    ]);
+  });
+
+  test("dims the directory and names the program the first token really is", () => {
+    const line = colorProcessCommand("/usr/bin/bash --login -l notes.txt");
+    //  Colour is the only difference: the text itself is untouched.
+    expect(Bun.stripANSI(line)).toBe("/usr/bin/bash --login -l notes.txt");
+    expect(line).toContain(wrap("path", "/usr/bin/"));
+    expect(line).toContain(wrap("type", "bash"));
+    expect(line).toContain(wrap("statement", "--login"));
+    expect(line).toContain(wrap("statement", "-l"));
+    //  An ordinary operand is left alone.
+    expect(line).toContain(" notes.txt");
+    //  Word boundaries are micro's: the `sh` ending `script.sh` is one of
+    //  sh.yaml's command names, and it is painted like one here too.
+    expect(colorProcessCommand("bun run script.sh")).toContain(wrap("type", "sh"));
+
+    //  A program sh.yaml's word lists have never heard of is still the
+    //  command, because here the first token is known to be one.
+    expect(colorProcessCommand("fish")).toBe(wrap("type", "fish"));
+    expect(colorProcessCommand("")).toBe("");
+  });
+
+  test("applies sh.yaml's rules to the rest of the command line", () => {
+    const source = 'if test 42 = "$HOME"; then echo ok; fi # note';
+    const line = highlightShellCommand(source);
+    expect(Bun.stripANSI(line)).toBe(source);
+    expect(line).toContain(wrap("statement", "if"));
+    expect(line).toContain(wrap("statement", "then"));
+    expect(line).toContain(wrap("constant", "42"));
+    expect(line).toContain(wrap("type", "test"));
+    expect(line).toContain(wrap("special", "="));
+    //  The string is a region, so it swallows the $HOME inside it.
+    expect(line).toContain(wrap("string", '"$HOME"'));
+    expect(line).toContain(wrap("comment", "# note"));
+    expect(highlightShellCommand("run $HOME/bin ${PATH}"))
+      .toContain(wrap("identifier", "$HOME"));
+  });
+
+  test("resolves rule precedence the way micro does", () => {
+    //  The flag rule is listed after the command names, so it wins the
+    //  overlap: --cat is a flag, not the coreutils cat.
+    expect(highlightShellCommand("bun --cat run")).toContain(wrap("statement", "--cat"));
+    //  A # inside a quoted argument does not open a comment.
+    const quoted = highlightShellCommand('echo "a # b" done');
+    expect(quoted).toContain(wrap("string", '"a # b"'));
+    expect(quoted).toContain(wrap("statement", "done"));
+  });
+
+  test("lets a kernel thread and a quoted program keep their own colour", () => {
+    expect(colorProcessCommand("[kworker/0:1]")).toBe(wrap("path", "[kworker/0:1]"));
+    const windows = colorProcessCommand('"C:\\Program Files\\App\\app.exe" --flag');
+    expect(Bun.stripANSI(windows)).toBe('"C:\\Program Files\\App\\app.exe" --flag');
+    expect(windows).toContain(wrap("string", '"C:\\Program Files\\App\\app.exe"'));
+    expect(windows).toContain(wrap("statement", "--flag"));
+  });
+
+  test("strips back to exactly what pspa prints", () => {
+    const rows = [
+      { pid: 1, args: "/init" },
+      { pid: 4, args: "" },
+      { pid: 123456, args: "/usr/bin/bun run dev" },
+    ];
+    expect(Bun.stripANSI(colorProcessTable(rows))).toBe(formatProcessTable(rows));
+  });
+
+  test("lists the same processes pspa does, in colour", async () => {
+    const execution = await executeArgv(["builtin", "pspac"], createState(), { capture: true });
+    expect(execution.status).toBe(0);
+    const text = decode(execution.stdout);
+    expect(text).toContain("\x1b[");
+    const lines = Bun.stripANSI(text).split("\n");
+    expect(lines[0]).toMatch(/^\s*PID COMMAND$/);
+    expect(lines.some((line) => new RegExp(`^\\s*${process.pid} `).test(line))).toBe(true);
+  });
+
+  test("takes no operands", async () => {
+    const execution = await executeArgv(["builtin", "pspac", "extra"], createState(), { capture: true });
+    expect(execution.status).toBe(2);
+    expect(decode(execution.stderr)).toBe("bunmsh: pspac: unexpected operand: extra\n");
+  });
+});
+
+describe("variable completion", () => {
+  const state = { env: { HOME: "/home/user", HOSTNAME: "box", PATH: "/bin", LOCAL_ONLY: "x" } };
+
+  test("recognizes a name being typed after $, ${, and ${#", () => {
+    expect(variableContext("echo $HO")).toMatchObject({ prefix: "HO", lead: "$", brace: false });
+    expect(variableContext("echo ${HO")).toMatchObject({ prefix: "HO", lead: "${", brace: true });
+    expect(variableContext("echo ${#HO")).toMatchObject({ prefix: "HO", lead: "${#", brace: true });
+    //  A bare $ is a name with nothing typed yet, not a non-match.
+    expect(variableContext("echo $")).toMatchObject({ prefix: "", lead: "$" });
+    //  Position on the line does not matter: inside double quotes, on the
+    //  right of an assignment, or where a command name would go.
+    expect(variableContext('echo "$HO')).toMatchObject({ prefix: "HO" });
+    expect(variableContext("X=$HO")).toMatchObject({ prefix: "HO" });
+    expect(variableContext("$ED")).toMatchObject({ prefix: "ED" });
+  });
+
+  test("leaves alone every other thing a $ can start", () => {
+    expect(variableContext("echo $(")).toBeNull();
+    expect(variableContext("echo $(l")).toBeNull();
+    expect(variableContext("echo $?")).toBeNull();
+    expect(variableContext("echo $1")).toBeNull();
+    //  $$ is the pid, already complete; the second $ is not a name opening.
+    expect(variableContext("echo $$")).toBeNull();
+    expect(variableContext("echo hi")).toBeNull();
+    expect(variableContext("echo $HOME ")).toBeNull();
+  });
+
+  test("counts backslashes so an escaped dollar stays literal", () => {
+    expect(variableContext(String.raw`echo \$HO`)).toBeNull();
+    //  An escaped backslash is not escaping the dollar.
+    expect(variableContext(String.raw`echo \\$HO`)).toMatchObject({ prefix: "HO" });
+    expect(variableContext(String.raw`echo \\\$HO`)).toBeNull();
+  });
+
+  test("completes from the shell's own table, exported or not", () => {
+    const index = new VariableIndex();
+    expect(index.matches(state, "HO")).toEqual(["HOME", "HOSTNAME"]);
+    expect(index.first(state, "LOCAL")).toBe("LOCAL_ONLY");
+    expect(index.first(state, "ZZ")).toBeNull();
+    //  An empty prefix lists everything, the way Tab on an empty word does.
+    expect(index.matches(state, "")).toEqual(["HOME", "HOSTNAME", "LOCAL_ONLY", "PATH"]);
+    expect(index.first(state, "")).toBeNull();
+  });
+
+  test("picks up a name added after the index was first built", () => {
+    const index = new VariableIndex();
+    const live = { env: { ...state.env } };
+    expect(index.first(live, "TA")).toBeNull();
+    live.env.TAG = "v1";
+    expect(index.first(live, "TA")).toBe("TAG");
+  });
+
+  test("closes the brace it was given", () => {
+    expect(variableCompletion(variableContext("echo $HO"), "HOME")).toBe("$HOME");
+    expect(variableCompletion(variableContext("echo ${HO"), "HOME")).toBe("${HOME}");
+    expect(variableCompletion(variableContext("echo ${#HO"), "HOME")).toBe("${#HOME}");
+  });
+
+  test("reports the quote a word is inside, so nothing expands in single quotes", () => {
+    expect(completionContext("echo 'foo")).toMatchObject({ quote: "'" });
+    expect(completionContext('echo "foo')).toMatchObject({ quote: '"' });
+    expect(completionContext("echo foo")).toMatchObject({ quote: null });
+  });
+
+  test("treats $( as a command position and ) as the end of one", () => {
+    expect(completionContext("echo $(l")).toMatchObject({ command: true, prefix: "l" });
+    expect(completionContext("echo $(ls /tm")).toMatchObject({ command: false, prefix: "/tm" });
+    expect(completionContext("echo $(date) fi")).toMatchObject({ command: false, prefix: "fi" });
+  });
+});
+
+describe("javascript mode completion", () => {
+  test("decides mode by the rule the evaluator dispatches on", () => {
+    expect(isJavaScriptMode("Bun.e, 1")).toBe(true);
+    expect(isJavaScriptMode("  Bun.file('x')")).toBe(true);
+    expect(isJavaScriptMode("echo Bun.e")).toBe(false);
+  });
+
+  test("stops offering a continuation a JavaScript line could never accept", () => {
+    //  A bare trailing backslash is a syntax error in JavaScript, not a
+    //  request for another line, so the prompt no longer asks for one.
+    expect(needsMoreInput("Bun.e; const p = \\")).toBe(false);
+    //  An unterminated string still continues: that is JavaScript's own line
+    //  continuation, and the evaluator accepts it.
+    expect(needsMoreInput('Bun.e, "abc\\')).toBe(true);
+    expect(needsMoreInput("Bun.e, `abc")).toBe(true);
+    //  Shell text is untouched.
+    expect(needsMoreInput("echo hi \\")).toBe(true);
+    expect(needsMoreInput('echo "abc')).toBe(true);
+    expect(needsMoreInput("echo hi")).toBe(false);
+  });
+
+  test("completes a shell variable after $. and nothing after a bare $", () => {
+    expect(javascriptContext("Bun.e, $.HO")).toMatchObject({ kind: "variable", prefix: "HO", lead: "$." });
+    expect(javascriptContext("Bun.e, $.")).toMatchObject({ kind: "variable", prefix: "" });
+    //  In JavaScript a bare `$` is the table object itself; a name only
+    //  starts after the dot.
+    expect(javascriptContext("Bun.e, $")).toBeNull();
+    expect(javascriptContext("Bun.e, 1 + 2")).toBeNull();
+  });
+
+  test("completes a path inside an unclosed string literal", () => {
+    expect(javascriptContext('Bun.e, Bun.file("/tm')).toMatchObject({ kind: "path", prefix: "/tm", quote: '"' });
+    expect(javascriptContext("Bun.e, Bun.file('/tm")).toMatchObject({ kind: "path", prefix: "/tm", quote: "'" });
+    expect(javascriptContext("Bun.e, Bun.file(`/tm")).toMatchObject({ kind: "path", prefix: "/tm", quote: "`" });
+    //  A closed string is not a path being typed.
+    expect(javascriptContext('Bun.e, Bun.file("/tmp/x")')).toBeNull();
+    //  An escaped quote does not close it.
+    expect(javascriptContext('Bun.e, "it\\"s /tm')).toMatchObject({ kind: "path", prefix: 'it\\"s /tm' });
+  });
+
+  test("treats a template interpolation as code again", () => {
+    //  Inside ${ } the cursor is back in JavaScript, so $. completes there.
+    expect(javascriptContext("Bun.e, `a${$.HO")).toMatchObject({ kind: "variable", prefix: "HO" });
+    //  And the template resumes after the closing brace.
+    expect(javascriptContext("Bun.e, `a${b}/tm")).toMatchObject({ kind: "path", quote: "`" });
+  });
+});

package/bin/install.js

@@ -195,14 +195,20 @@ const DIFF_TIMEOUT_MS = 60_000;
 // the user changed. Files it calls added are theirs and are never deleted by
 // an update; only modified ones are about to be written over.
 async function findLocalChanges(destination, version) {
-  const child = Bun.spawn(
-    [
-      process.execPath, "pm", "diff",
-      `${pkg.name}@${version}`, destination,
-      "--name-only", "--json",
-    ],
-    { stdin: "ignore", stdout: "pipe", stderr: "pipe" },
-  );
+  const argv = [
+    process.execPath, "pm", "diff",
+    `${pkg.name}@${version}`, destination,
+    "--name-only", "--json",
+  ];
+
+  // On a line of its own, unprefixed, and on stdout rather than stderr with
+  // the rest of the output, so it stands out and `2>/dev/null` leaves just the
+  // command: copy it and run it by hand without --json to read the list, or
+  // without --name-only to see the changes themselves rather than which files
+  // hold them.
+  console.log(`  ${argv.join(" ")}`);
+
+  const child = Bun.spawn(argv, { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
 
   let timedOut = false;
   const timer = setTimeout(() => {
@@ -241,14 +247,28 @@ async function findLocalChanges(destination, version) {
     return { files: null, error: "bun pm diff did not return JSON" };
   }
 
+  const modified = (report.files ?? [])
+    .filter((file) => file.status === "modified" && !MERGED_PATHS.has(file.path));
+
   return {
-    files: (report.files ?? [])
-      .filter((file) => file.status === "modified" && !MERGED_PATHS.has(file.path))
-      .map((file) => file.path),
+    files: modified.filter((file) => !isModeOnlyChange(file)).map((file) => file.path),
+    modeOnly: modified.filter(isModeOnlyChange).length,
     error: null,
   };
 }
 
+// Publishing normalises file modes, so a file can come back from the registry
+// with a different executable bit and identical contents. bun pm diff calls
+// that a modification, and reporting it would mean a freshly installed tree
+// listing files nobody has touched. modeBefore and modeAfter are only present
+// when the mode differs at all; the rest is what says the bytes did not.
+function isModeOnlyChange(file) {
+  return file.modeBefore !== undefined &&
+    file.linesAdded === 0 &&
+    file.linesRemoved === 0 &&
+    file.bytesBefore === file.bytesAfter;
+}
+
 // Returns null when there is no terminal to ask at, which the caller reports
 // rather than treating as either answer.
 async function confirm(question) {
@@ -426,7 +446,7 @@ async function confirmLocalChanges(destination, version, options) {
   // sit there for a while with nothing on screen to explain the wait.
   console.error(`${pkg.name}: comparing it against the published ${version} for local changes...`);
 
-  const { files, error } = await findLocalChanges(destination, version);
+  const { files, modeOnly, error } = await findLocalChanges(destination, version);
 
   // The check needs the registry, so it cannot run offline or against a version
   // that was never published. Whether anything was edited locally is then
@@ -448,6 +468,15 @@ async function confirmLocalChanges(destination, version, options) {
     return false;
   }
 
+  // Worth saying rather than hiding: it explains why the count here is smaller
+  // than the one the printed command reports, and a mode that keeps coming back
+  // is worth knowing about even though an update is not what changed it.
+  if (modeOnly) {
+    console.error(
+      `${pkg.name}: ${modeOnly} file(s) differ only in file mode, with identical contents; ignoring them`,
+    );
+  }
+
   if (!files.length) return false;
 
   console.error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Buninu is a portable, self-bootstrapping Unix-like userspace built on Bun that runs across operating systems",
   "type": "module",
   "main": "./bin/init.js",