buninu-linux 0.7.2 → 0.7.3

package/initramfs/buninu/apps/jsgotty/NOTICE

@@ -19,3 +19,103 @@ Included third-party component:
 
 The bundled file [static/js/zmodem.js] is byte-for-byte identical to the
 upstream npm release zmodem.js version 0.1.10 dist/zmodem.js.
+
+2. ConPTY - Windows pseudoconsole library and console host
+   (conpty/conpty.dll, conpty/OpenConsole.exe), part of Windows Terminal
+   Copyright (c) Microsoft Corporation. All rights reserved.
+   Licensed under the MIT License
+   Upstream: https://github.com/microsoft/terminal
+   Local copy of license text:
+   LICENSES/MIT-microsoft-terminal-conpty.txt
+   Upstream third-party notices for Windows Terminal:
+   LICENSES/NOTICE-microsoft-terminal-conpty.md
+
+The bundled files in [conpty/] are byte-for-byte identical to the win-x64
+binaries in the official NuGet package
+Microsoft.Windows.Console.ConPTY 1.25.260710002-preview, published with the
+Windows Terminal Preview v1.25.1912.0 release
+(https://github.com/microsoft/terminal/releases/tag/v1.25.1912.0):
+
+   conpty/conpty.dll       (runtimes/win-x64/native/conpty.dll)
+     SHA-256 e2fe87e2258c4e46ffc5157f727218cc25f34a174902f72eb8a5b49edd9a6458
+   conpty/OpenConsole.exe  (build/native/runtimes/x64/OpenConsole.exe)
+     SHA-256 2525c351aa136d555e5df9a3c9d6ce9be43f785e37e3c993b8f23b3f0a53c7fa
+
+The license and notice files are taken verbatim from the microsoft/terminal
+repository at tag v1.25.1912.0. The notice file lists third-party components
+used across Windows Terminal; it is included in full because the subset built
+into these two binaries is not documented separately.
+
+3. node-pty 1.1.0 - forkpty(3) bindings for Node.js (lib/node-pty)
+   Copyright (c) 2012-2015, Christopher Jeffrey
+   Copyright (c) 2016, Daniel Imms
+   Copyright (c) 2018 - present Microsoft Corporation
+   Licensed under the MIT License
+   Upstream: https://github.com/microsoft/node-pty
+   License text: lib/node-pty/LICENSE
+
+   node-pty in turn bundles:
+
+   a. winpty 0.4.4-dev (lib/node-pty/deps/winpty,
+      lib/node-pty/prebuilds/win32-*/winpty.dll and winpty-agent.exe)
+      Copyright (c) 2011-2016 Ryan Prichard
+      Licensed under the MIT License
+      Upstream: https://github.com/rprichard/winpty
+      License text: lib/node-pty/deps/winpty/LICENSE
+
+   b. ConPTY 1.23.251008001 from Windows Terminal
+      (lib/node-pty/prebuilds/win32-*/conpty/conpty.dll and OpenConsole.exe)
+      Copyright (c) Microsoft Corporation. All rights reserved.
+      Licensed under the MIT License; see item 2 for the license and
+      Windows Terminal notice files.
+
+The prebuilt binaries under [lib/node-pty/prebuilds] and the license files
+lib/node-pty/LICENSE and lib/node-pty/deps/winpty/LICENSE are byte-for-byte
+identical to those in the upstream npm release node-pty 1.1.0; they are not
+rebuilt by this project.
+
+The files in [patches/] (windowsPtyAgent.js, windowsTerminal.js) are modified
+copies of node-pty source files; they keep node-pty's copyright headers and
+remain under its MIT License.
+
+4. npm dependencies committed under [node_modules/]
+
+   a. ws 8.21.0 - WebSocket client and server
+      Copyright (c) 2011 Einar Otto Stangvik
+      Copyright (c) 2013 Arnout Kazemier and contributors
+      Copyright (c) 2016 Luigi Pinca and contributors
+      Licensed under the MIT License
+      License text: node_modules/ws/LICENSE (also LICENSES/MIT-ws.txt,
+      which single executables carry because ws is bundled into them)
+
+   b. node-addon-api 7.1.1 - C++ headers used to build node-pty
+      Copyright (c) 2017 Node.js API collaborators
+      Licensed under the MIT License
+      License text: node_modules/node-addon-api/LICENSE.md
+
+5. Web client assets under [static/]
+
+   static/js/gotty.js is a webpack bundle. The licenses of every package it
+   contains (xterm.js and its fit, web-links, webgl and unicode11 addons,
+   Bootstrap, Popper, Preact, crc-32, zmodem.js, css-loader, style-loader)
+   are listed in static/js/gotty.licenses.txt, with the retained banners in
+   static/js/gotty.js.LICENSE.txt.
+
+   static/js/xterm-addon-unicode11.js is byte-for-byte identical to
+   lib/addon-unicode11.js of the npm release @xterm/addon-unicode11 0.9.0, and
+   static/css/xterm.css comes from xterm.js
+   (Copyright (c) 2014 The xterm.js authors; Copyright (c) 2012-2013
+   Christopher Jeffrey; MIT License, text in static/js/gotty.licenses.txt).
+
+   static/favicon.ico, static/icon.svg and static/icon_192.png are
+   byte-for-byte identical to the icons of GoTTY
+   (https://github.com/sorenisanerd/gotty), covered by the MIT License and
+   the GoTTY copyright notices in LICENSE.
+
+Single executables built with --build-exe / --build-for embed the Bun
+runtime. Bun is MIT-licensed but statically links JavaScriptCore and WebKit
+(LGPL-2) and other libraries under their own licenses; anyone distributing
+such an executable must also follow Bun's license terms, including the LGPL
+relinking provisions described at
+https://github.com/oven-sh/bun/blob/main/LICENSE.md. The executables carry
+LICENSE, NOTICE and LICENSES/ as embedded assets.

package/initramfs/buninu/apps/jsgotty/gotty.js

@@ -115,6 +115,26 @@ function assetFilePath(key) {
   return assets ? assets.assetDiskPath(key) : path.join(__dirname, key);
 }
 
+function windowsConptyDllPath() {
+  const dll = assetFilePath("conpty/conpty.dll");
+  if (fs.existsSync(dll)) return dll;
+  if (!assets) return null;
+  try {
+    const dllBytes = assets.readAssetBytesSync("conpty/conpty.dll");
+    const hostBytes = assets.readAssetBytesSync("conpty/OpenConsole.exe");
+    const version = crypto.createHash("sha256").update(dllBytes).digest("hex").slice(0, 16);
+    const dir = path.join(os.tmpdir(), `jsgotty-conpty-${version}`);
+    fs.mkdirSync(dir, { recursive: true });
+    for (const [name, bytes] of [["conpty.dll", dllBytes], ["OpenConsole.exe", hostBytes]]) {
+      const dest = path.join(dir, name);
+      if (!fs.existsSync(dest)) fs.writeFileSync(dest, bytes);
+    }
+    return path.join(dir, "conpty.dll");
+  } catch (error) {
+    throw new Error(`Could not prepare bundled ConPTY: ${error.message}`);
+  }
+}
+
 //  URL-relative path -> asset key, or null when it escapes `static/`.
 //  Normalizing against "/" is what makes "../../etc/passwd" unreachable.
 function staticAssetKey(relativePath) {
@@ -1624,6 +1644,10 @@ function createPtyBackend(options) {
     if (globalThis.Bun?.semver?.satisfies?.(
         globalThis.Bun?.version, ">=1.3.14"
       )) {
+      const conptyDll = windowsConptyDllPath();
+      if (conptyDll) {
+        return new (require("./windows-conpty.js"))(options, conptyDll);
+      }
       return new BunPtyBackend(options);
     }
     return new NodePtyBackend(options);

package/initramfs/buninu/apps/jsgotty/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "jsgotty",
-  "version": "1.1.11",
+  "version": "1.1.14",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jsgotty",
-      "version": "1.1.11",
+      "version": "1.1.14",
       "dependencies": {
         "node-addon-api": "^7.1.1",
         "ws": "^8.18.3"

package/initramfs/buninu/apps/jsgotty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgotty",
-  "version": "1.1.12",
+  "version": "1.1.14",
   "description": "Share your terminal as a web application: A JavaScript rewrite of GoTTY",
   "license": "MIT",
   "bin": {
@@ -8,9 +8,13 @@
   },
   "type": "commonjs",
   "assets": [
+    "conpty",
     "static",
     "README.md",
-    "README.en.md"
+    "README.en.md",
+    "LICENSE",
+    "NOTICE",
+    "LICENSES"
   ],
   "dependencies": {
     "node-addon-api": "^7.1.1",

package/initramfs/buninu/apps/jsgotty/windows-conpty.js

@@ -0,0 +1,135 @@
+// Windows PTY adapter for the out-of-band Microsoft Console package.
+// Keep the same interface as BunPtyBackend in gotty.js.
+const { dlopen, ptr } = require("bun:ffi");
+const path = require("path");
+
+const kernel = dlopen("kernel32.dll", {
+  CreatePipe: { args: ["ptr", "ptr", "ptr", "u32"], returns: "i32" },
+  InitializeProcThreadAttributeList: { args: ["ptr", "u32", "u32", "ptr"], returns: "i32" },
+  UpdateProcThreadAttribute: { args: ["ptr", "u32", "usize", "ptr", "usize", "ptr", "ptr"], returns: "i32" },
+  DeleteProcThreadAttributeList: { args: ["ptr"], returns: "void" },
+  CreateProcessW: { args: ["ptr", "ptr", "ptr", "ptr", "i32", "u32", "ptr", "ptr", "ptr", "ptr"], returns: "i32" },
+  PeekNamedPipe: { args: ["ptr", "ptr", "u32", "ptr", "ptr", "ptr"], returns: "i32" },
+  ReadFile: { args: ["ptr", "ptr", "u32", "ptr", "ptr"], returns: "i32" },
+  WriteFile: { args: ["ptr", "ptr", "u32", "ptr", "ptr"], returns: "i32" },
+  GetExitCodeProcess: { args: ["ptr", "ptr"], returns: "i32" },
+  TerminateProcess: { args: ["ptr", "u32"], returns: "i32" },
+  CloseHandle: { args: ["ptr"], returns: "i32" },
+  GetLastError: { args: [], returns: "u32" },
+}).symbols;
+
+const conptySymbols = {
+  ConptyCreatePseudoConsole: { args: ["u32", "ptr", "ptr", "u32", "ptr"], returns: "i32" },
+  ConptyResizePseudoConsole: { args: ["ptr", "u32"], returns: "i32" },
+  ConptyClosePseudoConsole: { args: ["ptr"], returns: "void" },
+};
+const wide = (value) => Buffer.from(`${value}\0`, "utf16le");
+const handle = (buffer) => Number(buffer.readBigUInt64LE(0));
+const size = (cols, rows) => ((Math.max(1, rows) & 0xffff) << 16) | (Math.max(1, cols) & 0xffff);
+const winError = (operation) => new Error(`${operation} failed: ${kernel.GetLastError()}`);
+// Windows CRT argv escaping: double backslashes before quotes and at the end.
+function quoteArg(value) {
+  let result = '"', slashes = 0;
+  for (const char of String(value)) {
+    if (char === "\\") { slashes++; continue; }
+    if (char === '"') result += "\\".repeat(slashes * 2 + 1) + '"';
+    else result += "\\".repeat(slashes) + char;
+    slashes = 0;
+  }
+  return result + "\\".repeat(slashes * 2) + '"';
+}
+
+class WindowsConptyBackend {
+  constructor(options, dllPath) {
+    this.options = options;
+    this.dataHandlers = [];
+    this.exitHandlers = [];
+    this.closed = false;
+    this.conpty = dlopen(path.resolve(dllPath), conptySymbols).symbols;
+    const inputRead = Buffer.alloc(8), inputWrite = Buffer.alloc(8);
+    const outputRead = Buffer.alloc(8), outputWrite = Buffer.alloc(8);
+    if (!kernel.CreatePipe(inputRead, inputWrite, 0, 0)) throw winError("CreatePipe input");
+    if (!kernel.CreatePipe(outputRead, outputWrite, 0, 0)) throw winError("CreatePipe output");
+    this.input = handle(inputWrite);
+    this.output = handle(outputRead);
+    const pseudo = Buffer.alloc(8);
+    const hr = this.conpty.ConptyCreatePseudoConsole(
+      size(options.width || 80, options.height || 24), handle(inputRead), handle(outputWrite), 0, pseudo);
+    kernel.CloseHandle(handle(inputRead));
+    kernel.CloseHandle(handle(outputWrite));
+    if (hr !== 0) throw new Error(`ConptyCreatePseudoConsole failed: ${hr}`);
+    this.pseudo = handle(pseudo);
+
+    const listSize = Buffer.alloc(8);
+    kernel.InitializeProcThreadAttributeList(0, 1, 0, listSize);
+    const list = Buffer.alloc(Number(listSize.readBigUInt64LE(0)));
+    if (!kernel.InitializeProcThreadAttributeList(list, 1, 0, listSize)) throw winError("InitializeProcThreadAttributeList");
+    if (!kernel.UpdateProcThreadAttribute(list, 0, 0x00020016, this.pseudo, 8, 0, 0)) throw winError("UpdateProcThreadAttribute");
+    const startup = Buffer.alloc(112);
+    startup.writeUInt32LE(112, 0);
+    startup.writeUInt32LE(0x100, 60); // STARTF_USESTDHANDLES
+    startup.writeBigUInt64LE(BigInt(ptr(list)), 104);
+    const processInfo = Buffer.alloc(24);
+    const env = { ...process.env, TERM: "xterm-256color", ...(options.headerEnv || {}) };
+    const envBlock = wide(Object.entries(env).filter(([key]) => !key.startsWith("="))
+      .map(([key, value]) => `${key}=${value}`).join("\0") + "\0");
+    const executable = Bun.which(options.command) || options.command;
+    const command = wide([executable, ...options.argv].map(quoteArg).join(" "));
+    const ok = kernel.CreateProcessW(wide(executable), command, 0, 0, 0,
+      0x00080000 | 0x00000400, envBlock, wide(process.cwd()), startup, processInfo);
+    kernel.DeleteProcThreadAttributeList(list);
+    if (!ok) throw winError("CreateProcessW");
+    this.process = handle(processInfo);
+    this.pid = processInfo.readUInt32LE(16);
+    kernel.CloseHandle(Number(processInfo.readBigUInt64LE(8)));
+    this.pollTimer = setInterval(() => this.poll(), 5);
+  }
+
+  onData(handler) { this.dataHandlers.push(handler); }
+  onExit(handler) { this.exitHandlers.push(handler); }
+  write(buffer) { this.writeBinary(buffer); }
+  writeBinary(buffer) {
+    const data = Buffer.from(buffer);
+    const written = Buffer.alloc(4);
+    for (let offset = 0; offset < data.length;) {
+      const chunk = data.subarray(offset);
+      if (!kernel.WriteFile(this.input, chunk, chunk.length, written, 0)) throw winError("WriteFile");
+      const count = written.readUInt32LE(0);
+      if (!count) throw new Error("WriteFile wrote no data");
+      offset += count;
+    }
+  }
+  resize(cols, rows) {
+    const hr = this.conpty.ConptyResizePseudoConsole(this.pseudo, size(cols, rows));
+    if (hr !== 0) throw new Error(`ConptyResizePseudoConsole failed: ${hr}`);
+  }
+  kill() { if (!this.closed) kernel.TerminateProcess(this.process, 1); }
+  close() { this.kill(); }
+
+  poll() {
+    if (this.closed) return;
+    const available = Buffer.alloc(4), readCount = Buffer.alloc(4);
+    if (kernel.PeekNamedPipe(this.output, 0, 0, 0, available, 0)) {
+      for (let bytes = available.readUInt32LE(0); bytes > 0; bytes = available.readUInt32LE(0)) {
+        const data = Buffer.alloc(Math.min(bytes, 65536));
+        if (!kernel.ReadFile(this.output, data, data.length, readCount, 0)) break;
+        const count = readCount.readUInt32LE(0);
+        if (!count) break;
+        for (const handler of this.dataHandlers) handler(data.subarray(0, count));
+        if (!kernel.PeekNamedPipe(this.output, 0, 0, 0, available, 0)) break;
+      }
+    }
+    const exitCode = Buffer.alloc(4);
+    if (kernel.GetExitCodeProcess(this.process, exitCode) && exitCode.readUInt32LE(0) !== 259) {
+      this.closed = true;
+      clearInterval(this.pollTimer);
+      this.conpty.ConptyClosePseudoConsole(this.pseudo);
+      kernel.CloseHandle(this.input);
+      kernel.CloseHandle(this.output);
+      kernel.CloseHandle(this.process);
+      for (const handler of this.exitHandlers) handler();
+    }
+  }
+}
+
+module.exports = WindowsConptyBackend;

package/initramfs/buninu/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu-linux",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "A Linux distribution running Bun as PID 1 with the Buninu userspace.",
   "type": "module",
   "main": "./index.js",