@ecmaos/kernel 0.6.5 → 0.6.6

package/dist/{kernel-C_Xvcpox.js → kernel-DZB_DlxI.js}

@@ -28621,7 +28621,7 @@ const _Dom = class _Dom {
   }
   async topbar(show) {
     if (!this._topbar) return;
-    const { default: topbar } = await import("./topbar.min-D7kPyIYf.js").then((n) => n.t);
+    const { default: topbar } = await import("./topbar.min-BAV19NIs.js").then((n) => n.t);
     this._topbarShow = show ?? !this._topbarShow;
     if (this._topbarShow) topbar.show();
     else topbar.hide();
@@ -59691,7 +59691,7 @@ const _TerminalCommand = class _TerminalCommand {
 };
 __name(_TerminalCommand, "TerminalCommand");
 let TerminalCommand = _TerminalCommand;
-function createCommand$i(kernel, shell, terminal) {
+function createCommand$l(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "cat",
     description: "Concatenate files and print on the standard output",
@@ -59706,6 +59706,8 @@ function createCommand$i(kernel, shell, terminal) {
     run: /* @__PURE__ */ __name(async (argv, process2) => {
       if (!process2) return 1;
       const writer = process2.stdout.getWriter();
+      const isTTY = process2.stdoutIsTTY ?? false;
+      let lastByte;
       try {
         if (!argv.path || !argv.path[0]) {
           const reader = process2.stdin.getReader();
@@ -59713,11 +59715,17 @@ function createCommand$i(kernel, shell, terminal) {
             while (true) {
               const { done, value } = await reader.read();
               if (done) break;
+              if (value.length > 0) {
+                lastByte = value[value.length - 1];
+              }
               await writer.write(value);
             }
           } finally {
             reader.releaseLock();
           }
+          if (isTTY && lastByte !== void 0 && lastByte !== 10) {
+            await writer.write(new Uint8Array([10]));
+          }
           return 0;
         }
         const files = argv.path || [];
@@ -59740,7 +59748,11 @@ function createCommand$i(kernel, shell, terminal) {
                 const data = new Uint8Array(chunkSize);
                 const readSize = Math.min(chunkSize, stat2.size - bytesRead);
                 await handle.read(data, 0, readSize, bytesRead);
-                await writer.write(data.subarray(0, readSize));
+                const chunk = data.subarray(0, readSize);
+                if (chunk.length > 0) {
+                  lastByte = chunk[chunk.length - 1];
+                }
+                await writer.write(chunk);
                 bytesRead += readSize;
               }
             } else {
@@ -59757,7 +59769,11 @@ function createCommand$i(kernel, shell, terminal) {
                 if (bytesRead > 0) {
                   const bytesToWrite = maxBytes ? Math.min(bytesRead, maxBytes - totalBytesRead) : bytesRead;
                   if (bytesToWrite > 0) {
-                    await writer.write(data.subarray(0, bytesToWrite));
+                    const chunk = data.subarray(0, bytesToWrite);
+                    if (chunk.length > 0) {
+                      lastByte = chunk[chunk.length - 1];
+                    }
+                    await writer.write(chunk);
                     totalBytesRead += bytesToWrite;
                   }
                 }
@@ -59767,16 +59783,18 @@ function createCommand$i(kernel, shell, terminal) {
             kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler);
           }
         }
+        if (isTTY && lastByte !== void 0 && lastByte !== 10) {
+          await writer.write(new Uint8Array([10]));
+        }
         return 0;
       } finally {
         writer.releaseLock();
-        await writeStdout(process2, terminal, "\n");
       }
     }, "run")
   });
 }
-__name(createCommand$i, "createCommand$i");
-function createCommand$h(kernel, shell, terminal) {
+__name(createCommand$l, "createCommand$l");
+function createCommand$k(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "cd",
     description: "Change the shell working directory",
@@ -59797,8 +59815,8 @@ function createCommand$h(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$h, "createCommand$h");
-function createCommand$g(kernel, shell, terminal) {
+__name(createCommand$k, "createCommand$k");
+function createCommand$j(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "chmod",
     description: "Change file mode bits",
@@ -59824,8 +59842,8 @@ function createCommand$g(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$g, "createCommand$g");
-function createCommand$f(kernel, shell, terminal) {
+__name(createCommand$j, "createCommand$j");
+function createCommand$i(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "cp",
     description: "Copy files",
@@ -59847,8 +59865,8 @@ function createCommand$f(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$f, "createCommand$f");
-function createCommand$e(kernel, shell, terminal) {
+__name(createCommand$i, "createCommand$i");
+function createCommand$h(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "echo",
     description: "Print arguments to the standard output",
@@ -59857,11 +59875,14 @@ function createCommand$e(kernel, shell, terminal) {
     terminal,
     options: [
       { name: "help", type: Boolean, description: kernel.i18n.t("Display help") },
+      { name: "n", type: Boolean, alias: "n", description: "Do not output the trailing newline" },
       { name: "text", type: String, typeLabel: "{underline text}", defaultOption: true, multiple: true, description: "The text to print" }
     ],
     run: /* @__PURE__ */ __name(async (argv, process2) => {
+      const noNewline = argv.n || false;
       const text = (argv.text || []).join(" ");
-      const data = new TextEncoder().encode(text + "\n");
+      const output2 = noNewline ? text : text + "\n";
+      const data = new TextEncoder().encode(output2);
       if (process2) {
         const writer = process2.stdout.getWriter();
         try {
@@ -59870,14 +59891,298 @@ function createCommand$e(kernel, shell, terminal) {
           writer.releaseLock();
         }
       } else {
-        terminal.write(text + "\n");
+        terminal.write(output2);
       }
       return 0;
     }, "run")
   });
 }
-__name(createCommand$e, "createCommand$e");
-function createCommand$d(kernel, shell, terminal) {
+__name(createCommand$h, "createCommand$h");
+function createCommand$g(kernel, shell, terminal) {
+  return new TerminalCommand({
+    command: "grep",
+    description: "Search for patterns in files or standard input",
+    kernel,
+    shell,
+    terminal,
+    options: [
+      { name: "help", type: Boolean, description: kernel.i18n.t("Display help") },
+      { name: "ignore-case", type: Boolean, alias: "i", description: "Ignore case distinctions" },
+      { name: "line-number", type: Boolean, alias: "n", description: "Print line number with output lines" },
+      { name: "args", type: String, defaultOption: true, multiple: true, description: "Pattern and file(s) to search" }
+    ],
+    run: /* @__PURE__ */ __name(async (argv, process2) => {
+      if (!process2) return 1;
+      const args = argv.args || [];
+      if (args.length === 0 || !args[0]) {
+        await writelnStderr(process2, terminal, "grep: pattern is required");
+        return 1;
+      }
+      const pattern2 = args[0];
+      const files = args.slice(1);
+      const ignoreCase = argv["ignore-case"] || false;
+      const showLineNumbers = argv["line-number"] || false;
+      const flags = ignoreCase ? "i" : "";
+      let regex;
+      try {
+        regex = new RegExp(pattern2, flags);
+      } catch (error) {
+        await writelnStderr(process2, terminal, `grep: invalid pattern: ${error instanceof Error ? error.message : "Unknown error"}`);
+        return 1;
+      }
+      const writer = process2.stdout.getWriter();
+      let exitCode = 0;
+      try {
+        if (files.length === 0) {
+          if (!process2.stdin) {
+            await writelnStderr(process2, terminal, "grep: No input provided");
+            return 1;
+          }
+          const reader = process2.stdin.getReader();
+          let currentLineNumber = 1;
+          let buffer2 = "";
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              const chunk = new TextDecoder().decode(value, { stream: true });
+              buffer2 += chunk;
+              const lines = buffer2.split("\n");
+              buffer2 = lines.pop() || "";
+              for (const line3 of lines) {
+                if (regex.test(line3)) {
+                  const output2 = showLineNumbers ? `${currentLineNumber}:${line3}
+` : `${line3}
+`;
+                  await writer.write(new TextEncoder().encode(output2));
+                }
+                currentLineNumber++;
+              }
+            }
+            if (buffer2 && regex.test(buffer2)) {
+              const output2 = showLineNumbers ? `${currentLineNumber}:${buffer2}
+` : `${buffer2}
+`;
+              await writer.write(new TextEncoder().encode(output2));
+            }
+          } finally {
+            reader.releaseLock();
+          }
+        } else {
+          for (const file of files) {
+            const fullPath = path$1.resolve(shell.cwd, file);
+            let interrupted = false;
+            const interruptHandler = /* @__PURE__ */ __name(() => {
+              interrupted = true;
+            }, "interruptHandler");
+            kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler);
+            try {
+              if (fullPath.startsWith("/dev")) {
+                await writelnStderr(process2, terminal, `grep: ${file}: cannot search device files`);
+                exitCode = 1;
+                continue;
+              }
+              const handle = await shell.context.fs.promises.open(fullPath, "r");
+              const stat2 = await shell.context.fs.promises.stat(fullPath);
+              let bytesRead = 0;
+              const chunkSize = 1024;
+              let buffer2 = "";
+              let currentLineNumber = 1;
+              while (bytesRead < stat2.size) {
+                if (interrupted) break;
+                const data = new Uint8Array(chunkSize);
+                const readSize = Math.min(chunkSize, stat2.size - bytesRead);
+                await handle.read(data, 0, readSize, bytesRead);
+                const chunk = data.subarray(0, readSize);
+                const text = new TextDecoder().decode(chunk, { stream: true });
+                buffer2 += text;
+                const lines = buffer2.split("\n");
+                buffer2 = lines.pop() || "";
+                for (const line3 of lines) {
+                  if (regex.test(line3)) {
+                    const prefix = files.length > 1 ? `${file}:` : "";
+                    const lineNumPrefix = showLineNumbers ? `${currentLineNumber}:` : "";
+                    const output2 = `${prefix}${lineNumPrefix}${line3}
+`;
+                    await writer.write(new TextEncoder().encode(output2));
+                  }
+                  currentLineNumber++;
+                }
+                bytesRead += readSize;
+              }
+              if (buffer2 && regex.test(buffer2)) {
+                const prefix = files.length > 1 ? `${file}:` : "";
+                const lineNumPrefix = showLineNumbers ? `${currentLineNumber}:` : "";
+                const output2 = `${prefix}${lineNumPrefix}${buffer2}
+`;
+                await writer.write(new TextEncoder().encode(output2));
+              }
+            } catch (error) {
+              await writelnStderr(process2, terminal, `grep: ${file}: ${error instanceof Error ? error.message : "Unknown error"}`);
+              exitCode = 1;
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler);
+            }
+          }
+        }
+        return exitCode;
+      } finally {
+        writer.releaseLock();
+      }
+    }, "run")
+  });
+}
+__name(createCommand$g, "createCommand$g");
+function createCommand$f(kernel, shell, terminal) {
+  return new TerminalCommand({
+    command: "head",
+    description: "Print the first lines of files",
+    kernel,
+    shell,
+    terminal,
+    options: [
+      { name: "help", type: Boolean, description: kernel.i18n.t("Display help") },
+      { name: "lines", type: Number, alias: "n", description: "Print the first NUM lines instead of the first 10" },
+      { name: "path", type: String, typeLabel: "{underline path}", defaultOption: true, multiple: true, description: "The path(s) to the file(s) to read" }
+    ],
+    run: /* @__PURE__ */ __name(async (argv, process2) => {
+      if (!process2) return 1;
+      const writer = process2.stdout.getWriter();
+      const numLines = argv.lines ?? 10;
+      try {
+        if (!argv.path || !argv.path[0]) {
+          if (!process2.stdin) {
+            return 0;
+          }
+          const reader = process2.stdin.getReader();
+          const decoder2 = new TextDecoder();
+          const lines = [];
+          let buffer2 = "";
+          try {
+            while (true) {
+              let readResult;
+              try {
+                readResult = await reader.read();
+              } catch (error) {
+                if (error instanceof Error) {
+                  throw error;
+                }
+                break;
+              }
+              const { done, value } = readResult;
+              if (done) {
+                buffer2 += decoder2.decode();
+                break;
+              }
+              if (value) {
+                buffer2 += decoder2.decode(value, { stream: true });
+                const newLines = buffer2.split("\n");
+                buffer2 = newLines.pop() || "";
+                lines.push(...newLines);
+                if (lines.length >= numLines) break;
+              }
+            }
+            if (buffer2 && lines.length < numLines) {
+              lines.push(buffer2);
+            }
+          } finally {
+            try {
+              reader.releaseLock();
+            } catch {
+            }
+          }
+          const output2 = lines.slice(0, numLines).join("\n");
+          if (output2) {
+            await writer.write(new TextEncoder().encode(output2 + "\n"));
+          }
+          return 0;
+        }
+        const files = argv.path || [];
+        const isMultipleFiles = files.length > 1;
+        for (let i = 0; i < files.length; i++) {
+          const file = files[i];
+          if (!file) continue;
+          const fullPath = path$1.resolve(shell.cwd, file);
+          if (isMultipleFiles) {
+            const header = i > 0 ? "\n" : "";
+            await writer.write(new TextEncoder().encode(`${header}==> ${file} <==
+`));
+          }
+          let interrupted = false;
+          const interruptHandler = /* @__PURE__ */ __name(() => {
+            interrupted = true;
+          }, "interruptHandler");
+          kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler);
+          try {
+            if (!fullPath.startsWith("/dev")) {
+              const handle = await shell.context.fs.promises.open(fullPath, "r");
+              const stat2 = await shell.context.fs.promises.stat(fullPath);
+              const decoder2 = new TextDecoder();
+              const lines = [];
+              let buffer2 = "";
+              let bytesRead = 0;
+              const chunkSize = 1024;
+              while (bytesRead < stat2.size && lines.length < numLines) {
+                if (interrupted) break;
+                const data = new Uint8Array(chunkSize);
+                const readSize = Math.min(chunkSize, stat2.size - bytesRead);
+                await handle.read(data, 0, readSize, bytesRead);
+                const chunk = data.subarray(0, readSize);
+                buffer2 += decoder2.decode(chunk, { stream: true });
+                const newLines = buffer2.split("\n");
+                buffer2 = newLines.pop() || "";
+                lines.push(...newLines);
+                bytesRead += readSize;
+                if (lines.length >= numLines) break;
+              }
+              if (buffer2 && lines.length < numLines) {
+                lines.push(buffer2);
+              }
+              const output2 = lines.slice(0, numLines).join("\n");
+              if (output2) {
+                await writer.write(new TextEncoder().encode(output2 + "\n"));
+              }
+            } else {
+              const device = await shell.context.fs.promises.open(fullPath);
+              const decoder2 = new TextDecoder();
+              const lines = [];
+              let buffer2 = "";
+              const chunkSize = 1024;
+              const data = new Uint8Array(chunkSize);
+              let bytesRead = 0;
+              do {
+                if (interrupted) break;
+                const result = await device.read(data);
+                bytesRead = result.bytesRead;
+                if (bytesRead > 0) {
+                  buffer2 += decoder2.decode(data.subarray(0, bytesRead), { stream: true });
+                  const newLines = buffer2.split("\n");
+                  buffer2 = newLines.pop() || "";
+                  lines.push(...newLines);
+                  if (lines.length >= numLines) break;
+                }
+              } while (bytesRead > 0 && lines.length < numLines);
+              if (buffer2 && lines.length < numLines) {
+                lines.push(buffer2);
+              }
+              const output2 = lines.slice(0, numLines).join("\n");
+              if (output2) {
+                await writer.write(new TextEncoder().encode(output2 + "\n"));
+              }
+            }
+          } finally {
+            kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler);
+          }
+        }
+        return 0;
+      } finally {
+        writer.releaseLock();
+      }
+    }, "run")
+  });
+}
+__name(createCommand$f, "createCommand$f");
+function createCommand$e(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "ln",
     description: "Create links between files",
@@ -59969,7 +60274,7 @@ function createCommand$d(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$d, "createCommand$d");
+__name(createCommand$e, "createCommand$e");
 var humanFormat$2 = { exports: {} };
 var humanFormat$1 = humanFormat$2.exports;
 var hasRequiredHumanFormat;
@@ -60250,7 +60555,7 @@ function requireHumanFormat() {
 __name(requireHumanFormat, "requireHumanFormat");
 var humanFormatExports = requireHumanFormat();
 const humanFormat = /* @__PURE__ */ getDefaultExportFromCjs(humanFormatExports);
-function createCommand$c(kernel, shell, terminal) {
+function createCommand$d(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "ls",
     description: "List directory contents",
@@ -60386,8 +60691,10 @@ function createCommand$c(kernel, shell, terminal) {
               const linkInfo = getLinkInfo(file.linkTarget, file.linkStats, file.stats);
               if (linkInfo) return linkInfo;
               if (descriptions.has(path$1.resolve(fullPath, file.name))) return descriptions.get(path$1.resolve(fullPath, file.name));
-              const ext = file.name.split(".").pop();
-              if (ext && descriptions.has("." + ext)) return descriptions.get("." + ext);
+              if (file.name.includes(".")) {
+                const ext = file.name.split(".").pop();
+                if (ext && descriptions.has("." + ext)) return descriptions.get("." + ext);
+              }
               if (!file.stats) return "";
               if (file.stats.isBlockDevice() || file.stats.isCharacterDevice()) ;
               return "";
@@ -60415,8 +60722,8 @@ function createCommand$c(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$c, "createCommand$c");
-function createCommand$b(kernel, shell, terminal) {
+__name(createCommand$d, "createCommand$d");
+function createCommand$c(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "mkdir",
     description: "Create a directory",
@@ -60435,8 +60742,8 @@ function createCommand$b(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$b, "createCommand$b");
-function createCommand$a(kernel, shell, terminal) {
+__name(createCommand$c, "createCommand$c");
+function createCommand$b(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "mv",
     description: "Move or rename files",
@@ -60475,8 +60782,8 @@ function createCommand$a(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$a, "createCommand$a");
-function createCommand$9(kernel, shell, terminal) {
+__name(createCommand$b, "createCommand$b");
+function createCommand$a(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "pwd",
     description: "Print the shell working directory",
@@ -60492,8 +60799,8 @@ function createCommand$9(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$9, "createCommand$9");
-function createCommand$8(kernel, shell, terminal) {
+__name(createCommand$a, "createCommand$a");
+function createCommand$9(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "rm",
     description: "Remove files or directories",
@@ -60513,8 +60820,8 @@ function createCommand$8(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$8, "createCommand$8");
-function createCommand$7(kernel, shell, terminal) {
+__name(createCommand$9, "createCommand$9");
+function createCommand$8(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "rmdir",
     description: "Remove a directory",
@@ -60533,7 +60840,7 @@ function createCommand$7(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$7, "createCommand$7");
+__name(createCommand$8, "createCommand$8");
 const MAX_32_BITS = 4294967295;
 const MAX_16_BITS = 65535;
 const MAX_8_BITS = 255;
@@ -65328,7 +65635,7 @@ const table = {
   return mimeTypes;
 })();
 t(configure);
-function createCommand$6(kernel, shell, terminal) {
+function createCommand$7(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "stat",
     description: "Display information about a file or directory",
@@ -65358,8 +65665,8 @@ function createCommand$6(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$6, "createCommand$6");
-function createCommand$5(kernel, shell, terminal) {
+__name(createCommand$7, "createCommand$7");
+function createCommand$6(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "touch",
     description: "Create an empty file",
@@ -65378,37 +65685,84 @@ function createCommand$5(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$5, "createCommand$5");
-function createCommand$4(kernel, shell, terminal) {
+__name(createCommand$6, "createCommand$6");
+function createCommand$5(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "hex",
-    description: "Display file contents in hexadecimal format",
+    description: "Display file contents or stdin in hexadecimal format",
     kernel,
     shell,
     terminal,
     options: [
       { name: "help", type: Boolean, description: kernel.i18n.t("Display help") },
-      { name: "path", type: String, typeLabel: "{underline path}", defaultOption: true, description: "The path to the file to display" }
+      { name: "path", type: String, typeLabel: "{underline path}", defaultOption: true, description: "The path to the file to display (if omitted, reads from stdin)" }
     ],
     run: /* @__PURE__ */ __name(async (argv, process2) => {
+      if (!process2) return 1;
       const filePath = argv.path;
-      if (!filePath) {
-        await writelnStderr(process2, terminal, "Usage: hex <file>");
-        return 1;
-      }
-      const fullPath = path$1.resolve(shell.cwd, filePath);
+      let data;
       try {
-        const exists2 = await shell.context.fs.promises.exists(fullPath);
-        if (!exists2) {
-          await writelnStderr(process2, terminal, `hex: ${filePath}: No such file or directory`);
-          return 1;
-        }
-        const stats = await shell.context.fs.promises.stat(fullPath);
-        if (stats.isDirectory()) {
-          await writelnStderr(process2, terminal, `hex: ${filePath}: Is a directory`);
-          return 1;
+        if (!filePath) {
+          if (!process2.stdin) {
+            await writelnStderr(process2, terminal, "Usage: hex <file>");
+            await writelnStderr(process2, terminal, "   or: <command> | hex");
+            return 1;
+          }
+          if (process2.stdinIsTTY) {
+            await writelnStderr(process2, terminal, "Usage: hex <file>");
+            await writelnStderr(process2, terminal, "   or: <command> | hex");
+            return 1;
+          }
+          const reader = process2.stdin.getReader();
+          const chunks = [];
+          try {
+            const first = await reader.read();
+            if (first.done && !first.value) {
+              await writelnStderr(process2, terminal, "Usage: hex <file>");
+              await writelnStderr(process2, terminal, "   or: <command> | hex");
+              return 1;
+            }
+            if (first.value) {
+              chunks.push(first.value);
+            }
+            if (!first.done) {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (value) {
+                  chunks.push(value);
+                }
+              }
+            }
+          } finally {
+            reader.releaseLock();
+          }
+          const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+          if (totalLength === 0) {
+            await writelnStderr(process2, terminal, "Usage: hex <file>");
+            await writelnStderr(process2, terminal, "   or: <command> | hex");
+            return 1;
+          }
+          data = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of chunks) {
+            data.set(chunk, offset);
+            offset += chunk.length;
+          }
+        } else {
+          const fullPath = path$1.resolve(shell.cwd, filePath);
+          const exists2 = await shell.context.fs.promises.exists(fullPath);
+          if (!exists2) {
+            await writelnStderr(process2, terminal, `hex: ${filePath}: No such file or directory`);
+            return 1;
+          }
+          const stats = await shell.context.fs.promises.stat(fullPath);
+          if (stats.isDirectory()) {
+            await writelnStderr(process2, terminal, `hex: ${filePath}: Is a directory`);
+            return 1;
+          }
+          data = await shell.context.fs.promises.readFile(fullPath);
         }
-        const data = await shell.context.fs.promises.readFile(fullPath);
         const bytesPerLine = 16;
         for (let offset = 0; offset < data.length; offset += bytesPerLine) {
           const lineBytes = data.slice(offset, offset + bytesPerLine);
@@ -65445,13 +65799,14 @@ function createCommand$4(kernel, shell, terminal) {
         }
         return 0;
       } catch (error) {
-        await writelnStderr(process2, terminal, `hex: ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        const errorPath = filePath || "stdin";
+        await writelnStderr(process2, terminal, `hex: ${errorPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
         return 1;
       }
     }, "run")
   });
 }
-__name(createCommand$4, "createCommand$4");
+__name(createCommand$5, "createCommand$5");
 const csi = "\x1B[";
 const ansi = {};
 ansi.style = {
@@ -65629,7 +65984,7 @@ ansi.erase = {
     return csi + (n || 0) + "K";
   }, "inLine")
 };
-function createCommand$3(kernel, shell, terminal) {
+function createCommand$4(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "less",
     description: "View file contents interactively",
@@ -65792,8 +66147,8 @@ function createCommand$3(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$3, "createCommand$3");
-function createCommand$2(kernel, shell, terminal) {
+__name(createCommand$4, "createCommand$4");
+function createCommand$3(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "passkey",
     description: "Manage passkey credentials for WebAuthn authentication",
@@ -65967,7 +66322,7 @@ function createCommand$2(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$2, "createCommand$2");
+__name(createCommand$3, "createCommand$3");
 function parseSedExpression(expr) {
   expr = expr.trim();
   const substituteMatch = expr.match(/^(\d+)?(,(\d+|\$))?s\/(.+?)\/(.*?)\/([gip]*\d*)$/);
@@ -66130,7 +66485,7 @@ function applySedCommand(line3, lineNum, totalLines, command) {
   return { result: line3, shouldPrint: false };
 }
 __name(applySedCommand, "applySedCommand");
-function createCommand$1(kernel, shell, terminal) {
+function createCommand$2(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "sed",
     description: "Stream editor for filtering and transforming text",
@@ -66325,8 +66680,8 @@ function createCommand$1(kernel, shell, terminal) {
     }, "run")
   });
 }
-__name(createCommand$1, "createCommand$1");
-function createCommand(kernel, shell, terminal) {
+__name(createCommand$2, "createCommand$2");
+function createCommand$1(kernel, shell, terminal) {
   return new TerminalCommand({
     command: "tee",
     description: "Read from standard input and write to standard output and files",
@@ -66402,28 +66757,173 @@ function createCommand(kernel, shell, terminal) {
     }, "run")
   });
 }
+__name(createCommand$1, "createCommand$1");
+function createCommand(kernel, shell, terminal) {
+  return new TerminalCommand({
+    command: "tail",
+    description: "Print the last lines of files",
+    kernel,
+    shell,
+    terminal,
+    options: [
+      { name: "help", type: Boolean, description: kernel.i18n.t("Display help") },
+      { name: "lines", type: Number, alias: "n", description: "Print the last NUM lines instead of the last 10" },
+      { name: "path", type: String, typeLabel: "{underline path}", defaultOption: true, multiple: true, description: "The path(s) to the file(s) to read" }
+    ],
+    run: /* @__PURE__ */ __name(async (argv, process2) => {
+      if (!process2) return 1;
+      const writer = process2.stdout.getWriter();
+      const numLines = argv.lines ?? 10;
+      try {
+        if (!argv.path || !argv.path[0]) {
+          if (!process2.stdin) {
+            return 0;
+          }
+          const reader = process2.stdin.getReader();
+          const decoder2 = new TextDecoder();
+          const lines = [];
+          let buffer2 = "";
+          try {
+            while (true) {
+              let readResult;
+              try {
+                readResult = await reader.read();
+              } catch (error) {
+                if (error instanceof Error) {
+                  throw error;
+                }
+                break;
+              }
+              const { done, value } = readResult;
+              if (done) {
+                buffer2 += decoder2.decode();
+                break;
+              }
+              if (value) {
+                buffer2 += decoder2.decode(value, { stream: true });
+                const newLines = buffer2.split("\n");
+                buffer2 = newLines.pop() || "";
+                lines.push(...newLines);
+              }
+            }
+            if (buffer2) {
+              lines.push(buffer2);
+            }
+          } finally {
+            try {
+              reader.releaseLock();
+            } catch {
+            }
+          }
+          const output2 = lines.slice(-numLines).join("\n");
+          if (output2) {
+            await writer.write(new TextEncoder().encode(output2 + "\n"));
+          }
+          return 0;
+        }
+        const files = argv.path || [];
+        const isMultipleFiles = files.length > 1;
+        for (let i = 0; i < files.length; i++) {
+          const file = files[i];
+          if (!file) continue;
+          const fullPath = path$1.resolve(shell.cwd, file);
+          if (isMultipleFiles) {
+            const header = i > 0 ? "\n" : "";
+            await writer.write(new TextEncoder().encode(`${header}==> ${file} <==
+`));
+          }
+          let interrupted = false;
+          const interruptHandler = /* @__PURE__ */ __name(() => {
+            interrupted = true;
+          }, "interruptHandler");
+          kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler);
+          try {
+            if (!fullPath.startsWith("/dev")) {
+              const handle = await shell.context.fs.promises.open(fullPath, "r");
+              const stat2 = await shell.context.fs.promises.stat(fullPath);
+              const decoder2 = new TextDecoder();
+              let buffer2 = "";
+              let bytesRead = 0;
+              const chunkSize = 1024;
+              while (bytesRead < stat2.size) {
+                if (interrupted) break;
+                const data = new Uint8Array(chunkSize);
+                const readSize = Math.min(chunkSize, stat2.size - bytesRead);
+                await handle.read(data, 0, readSize, bytesRead);
+                const chunk = data.subarray(0, readSize);
+                buffer2 += decoder2.decode(chunk, { stream: true });
+                bytesRead += readSize;
+              }
+              const lines = buffer2.split("\n");
+              if (lines[lines.length - 1] === "") {
+                lines.pop();
+              }
+              const output2 = lines.slice(-numLines).join("\n");
+              if (output2) {
+                await writer.write(new TextEncoder().encode(output2 + "\n"));
+              }
+            } else {
+              const device = await shell.context.fs.promises.open(fullPath);
+              const decoder2 = new TextDecoder();
+              const lines = [];
+              let buffer2 = "";
+              const chunkSize = 1024;
+              const data = new Uint8Array(chunkSize);
+              let bytesRead = 0;
+              do {
+                if (interrupted) break;
+                const result = await device.read(data);
+                bytesRead = result.bytesRead;
+                if (bytesRead > 0) {
+                  buffer2 += decoder2.decode(data.subarray(0, bytesRead), { stream: true });
+                }
+              } while (bytesRead > 0);
+              const allLines = buffer2.split("\n");
+              if (allLines[allLines.length - 1] === "") {
+                allLines.pop();
+              }
+              lines.push(...allLines);
+              const output2 = lines.slice(-numLines).join("\n");
+              if (output2) {
+                await writer.write(new TextEncoder().encode(output2 + "\n"));
+              }
+            }
+          } finally {
+            kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler);
+          }
+        }
+        return 0;
+      } finally {
+        writer.releaseLock();
+      }
+    }, "run")
+  });
+}
 __name(createCommand, "createCommand");
 function createAllCommands(kernel, shell, terminal) {
   return {
-    cat: createCommand$i(kernel, shell, terminal),
-    cd: createCommand$h(kernel, shell, terminal),
-    chmod: createCommand$g(kernel, shell, terminal),
-    cp: createCommand$f(kernel, shell, terminal),
-    echo: createCommand$e(kernel, shell, terminal),
-    ln: createCommand$d(kernel, shell, terminal),
-    ls: createCommand$c(kernel, shell, terminal),
-    mkdir: createCommand$b(kernel, shell, terminal),
-    mv: createCommand$a(kernel, shell, terminal),
-    pwd: createCommand$9(kernel, shell, terminal),
-    rm: createCommand$8(kernel, shell, terminal),
-    rmdir: createCommand$7(kernel, shell, terminal),
-    stat: createCommand$6(kernel, shell, terminal),
-    touch: createCommand$5(kernel, shell, terminal),
-    hex: createCommand$4(kernel, shell, terminal),
-    less: createCommand$3(kernel, shell, terminal),
-    passkey: createCommand$2(kernel, shell, terminal),
-    sed: createCommand$1(kernel, shell, terminal),
-    tee: createCommand(kernel, shell, terminal)
+    cat: createCommand$l(kernel, shell, terminal),
+    cd: createCommand$k(kernel, shell, terminal),
+    chmod: createCommand$j(kernel, shell, terminal),
+    cp: createCommand$i(kernel, shell, terminal),
+    echo: createCommand$h(kernel, shell, terminal),
+    grep: createCommand$g(kernel, shell, terminal),
+    head: createCommand$f(kernel, shell, terminal),
+    ln: createCommand$e(kernel, shell, terminal),
+    ls: createCommand$d(kernel, shell, terminal),
+    mkdir: createCommand$c(kernel, shell, terminal),
+    mv: createCommand$b(kernel, shell, terminal),
+    pwd: createCommand$a(kernel, shell, terminal),
+    rm: createCommand$9(kernel, shell, terminal),
+    rmdir: createCommand$8(kernel, shell, terminal),
+    stat: createCommand$7(kernel, shell, terminal),
+    touch: createCommand$6(kernel, shell, terminal),
+    hex: createCommand$5(kernel, shell, terminal),
+    less: createCommand$4(kernel, shell, terminal),
+    passkey: createCommand$3(kernel, shell, terminal),
+    sed: createCommand$2(kernel, shell, terminal),
+    tail: createCommand(kernel, shell, terminal),
+    tee: createCommand$1(kernel, shell, terminal)
   };
 }
 __name(createAllCommands, "createAllCommands");
@@ -66527,7 +67027,7 @@ const TerminalCommands = /* @__PURE__ */ __name((kernel, shell, terminal) => {
         { name: "reinstall", type: Boolean, description: "Reinstall the package if it is already installed" }
       ],
       run: /* @__PURE__ */ __name(async (argv) => {
-        const { default: install } = await import("./install-CNseKaMB.js");
+        const { default: install } = await import("./install-vHqmAl7t.js");
         return await install({ kernel, shell, terminal, args: [argv.package, argv.registry, argv.reinstall] });
       }, "run")
     }),
@@ -66542,7 +67042,7 @@ const TerminalCommands = /* @__PURE__ */ __name((kernel, shell, terminal) => {
         { name: "package", type: String, typeLabel: "{underline package}", defaultOption: true, description: "The package name and optional version (e.g. package@1.0.0). If no version is specified, all versions will be uninstalled." }
       ],
       run: /* @__PURE__ */ __name(async (argv) => {
-        const { default: uninstall } = await import("./uninstall-CamF7_kP.js");
+        const { default: uninstall } = await import("./uninstall-Ds11Scu8.js");
         return await uninstall({ kernel, shell, terminal, args: [argv.package] });
       }, "run")
     }),
@@ -66913,7 +67413,6 @@ const fetch$1 = /* @__PURE__ */ __name(async ({ shell, terminal, process: proces
     } finally {
       reader.releaseLock();
       writer?.releaseLock();
-      await writeStdout(process2, terminal, "\n");
     }
     return 0;
   } catch (error) {
@@ -67783,11 +68282,14 @@ const _Terminal = class _Terminal extends xtermExports.Terminal {
   async readline(prompt = "", hide = false, noListen = false) {
     let input = "";
     let cursor = 0;
-    if (!noListen) this.unlisten();
+    const wasListening = this._keyListener !== void 0;
+    this.unlisten();
     this.write(prompt);
     this.focus();
     const result = await new Promise((resolve2) => {
       const disposable = this.onKey(({ domEvent }) => {
+        domEvent.preventDefault();
+        domEvent.stopPropagation();
         switch (domEvent.key) {
           case "Enter":
             disposable.dispose();
@@ -67795,18 +68297,24 @@ const _Terminal = class _Terminal extends xtermExports.Terminal {
             resolve2(input);
             break;
           case "ArrowLeft":
-            this.write(ansi$7.cursor.back());
-            cursor--;
+            if (cursor > 0) {
+              this.write(ansi$7.cursor.back());
+              cursor--;
+            }
             break;
           case "ArrowRight":
-            this.write(ansi$7.cursor.forward());
-            cursor++;
+            if (cursor < input.length) {
+              this.write(ansi$7.cursor.forward());
+              cursor++;
+            }
             break;
           case "Home":
-            this.write(ansi$7.cursor.horizontalAbsolute(0));
+            this.write(ansi$7.cursor.horizontalAbsolute(prompt.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").length + 1));
+            cursor = 0;
             break;
           case "End":
-            this.write(ansi$7.cursor.horizontalAbsolute(input.length));
+            this.write(ansi$7.cursor.horizontalAbsolute(prompt.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").length + input.length + 1));
+            cursor = input.length;
             break;
           case "Escape":
             disposable.dispose();
@@ -67815,19 +68323,35 @@ const _Terminal = class _Terminal extends xtermExports.Terminal {
           case "Backspace":
             if (cursor > 0) {
               input = input.slice(0, cursor - 1) + input.slice(cursor);
-              this.write(ansi$7.cursor.horizontalAbsolute(0) + ansi$7.erase.inLine(2) + ":" + input);
+              const promptLen = prompt.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").length;
+              this.write(ansi$7.cursor.horizontalAbsolute(promptLen + 1) + ansi$7.erase.inLine(0) + input);
+              if (cursor < input.length + 1) {
+                this.write(`\x1B[${input.length + 1 - cursor}D`);
+              }
               cursor--;
             } else this.write("\x07");
             break;
           case "Delete":
-            if (cursor < input.length) input = input.slice(0, cursor) + input.slice(cursor + 1);
+            if (cursor < input.length) {
+              input = input.slice(0, cursor) + input.slice(cursor + 1);
+              this.write(ansi$7.erase.inLine(0) + input.slice(cursor));
+              if (input.length - cursor > 0) {
+                this.write(`\x1B[${input.length - cursor}D`);
+              }
+            }
             break;
           default:
             if (domEvent.key.length === 1 && !domEvent.ctrlKey && !domEvent.metaKey && !domEvent.altKey) {
               const charCode = domEvent.key.charCodeAt(0);
               if (charCode >= 32 && charCode <= 126) {
                 input = input.slice(0, cursor) + domEvent.key + input.slice(cursor);
-                if (!hide) this.write(ansi$7.cursor.horizontalAbsolute(0) + ansi$7.erase.inLine(2) + prompt + input);
+                if (!hide) {
+                  const promptLen = prompt.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").length;
+                  this.write(ansi$7.cursor.horizontalAbsolute(promptLen + 1) + ansi$7.erase.inLine(0) + input);
+                  if (cursor < input.length - 1) {
+                    this.write(`\x1B[${input.length - cursor - 1}D`);
+                  }
+                }
                 cursor++;
               }
             }
@@ -67836,7 +68360,7 @@ const _Terminal = class _Terminal extends xtermExports.Terminal {
         if (cursor > input.length) cursor = input.length;
       });
     });
-    if (!noListen) this.listen();
+    if (wasListening && !noListen) this.listen();
     return result;
   }
   spinner(spinner, prefix, suffix) {
@@ -68042,33 +68566,23 @@ const _Terminal = class _Terminal extends xtermExports.Terminal {
         break;
       case "Backspace":
         if (this._cursorPosition > 0) {
-          this._cmd = this._cmd.slice(0, this._cursorPosition - 1) + this._cmd.slice(this._cursorPosition);
+          const tail = this._cmd.slice(this._cursorPosition);
+          this._cmd = this._cmd.slice(0, this._cursorPosition - 1) + tail;
           this._cursorPosition--;
-          this.write("\b");
-          this.write(this._cmd.slice(this._cursorPosition) + " ");
-          this.write(`\x1B[${this._cmd.length - this._cursorPosition + 1}D`);
+          this.write("\b" + ansi$7.erase.inLine(0) + tail);
+          if (tail.length > 0) {
+            this.write(`\x1B[${tail.length}D`);
+          }
         } else this.write("\x07");
         break;
       case "Delete":
         if (this._cursorPosition < this._cmd.length) {
-          this._cmd = this._cmd.slice(0, this._cursorPosition) + this._cmd.slice(this._cursorPosition + 1);
-          this.write(ansi$7.erase.inLine(2) + ansi$7.cursor.horizontalAbsolute(0));
-          if (this._multiLineMode) {
-            const parts = this._cmd.split("#");
-            if (parts.length > 1) {
-              this.write("> " + parts[0] + chalk$2.gray("#" + parts.slice(1).join("#")));
-            } else {
-              this.write("> " + this._cmd);
-            }
-          } else {
-            const parts = this._cmd.split("#");
-            if (parts.length > 1) {
-              this.write(this.prompt() + parts[0] + chalk$2.gray("#" + parts.slice(1).join("#")));
-            } else {
-              this.write(this.prompt() + this._cmd);
-            }
+          const tail = this._cmd.slice(this._cursorPosition + 1);
+          this._cmd = this._cmd.slice(0, this._cursorPosition) + tail;
+          this.write(ansi$7.erase.inLine(0) + tail);
+          if (tail.length > 0) {
+            this.write(`\x1B[${tail.length}D`);
           }
-          if (this._cursorPosition < this._cmd.length) this.write(`\x1B[${this._cmd.length - this._cursorPosition}D`);
         }
         break;
       case "ArrowUp":
@@ -68171,25 +68685,18 @@ const _Terminal = class _Terminal extends xtermExports.Terminal {
       default:
         this._isTabCycling = false;
         if (key.length === 1) {
+          const wasAtEnd = this._cursorPosition === this._cmd.length;
           this._cmd = this._cmd.slice(0, this._cursorPosition) + key + this._cmd.slice(this._cursorPosition);
           this._cursorPosition++;
-          this.write(ansi$7.erase.inLine(2) + ansi$7.cursor.horizontalAbsolute(0));
-          if (this._multiLineMode) {
-            const parts = this._cmd.split("#");
-            if (parts.length > 1) {
-              this.write("> " + parts[0] + chalk$2.gray("#" + parts.slice(1).join("#")));
-            } else {
-              this.write("> " + this._cmd);
-            }
+          if (wasAtEnd) {
+            this.write(key);
           } else {
-            const parts = this._cmd.split("#");
-            if (parts.length > 1) {
-              this.write(this.prompt() + parts[0] + chalk$2.gray("#" + parts.slice(1).join("#")));
-            } else {
-              this.write(this.prompt() + this._cmd);
+            const tail = this._cmd.slice(this._cursorPosition);
+            this.write(key + tail);
+            if (tail.length > 0) {
+              this.write(`\x1B[${tail.length}D`);
             }
           }
-          if (this._cursorPosition < this._cmd.length) this.write(`\x1B[${this._cmd.length - this._cursorPosition}D`);
         }
     }
   }
@@ -71039,7 +71546,9 @@ const _Process = class _Process {
     __publicField(this, "_status", "stopped");
     __publicField(this, "_stderr");
     __publicField(this, "_stdin");
+    __publicField(this, "_stdinIsTTY");
     __publicField(this, "_stdout");
+    __publicField(this, "_stdoutIsTTY");
     __publicField(this, "_terminal");
     __publicField(this, "_uid");
     __publicField(this, "_keepAlive", false);
@@ -71060,7 +71569,9 @@ const _Process = class _Process {
     this._terminal = options.terminal || this.kernel.terminal;
     this._uid = options.uid;
     this._stdin = options.stdin || this.terminal.getInputStream();
+    this._stdinIsTTY = options.stdinIsTTY ?? (options.stdin ? false : true);
     this._stdout = options.stdout || this.terminal.stdout || new WritableStream();
+    this._stdoutIsTTY = options.stdoutIsTTY ?? (options.stdout ? false : true);
     this._stderr = options.stderr || this.terminal.stderr || new WritableStream();
     this._fdtable = new FDTable(this._stdin, this._stdout, this._stderr);
     this.kernel.processes.add(this);
@@ -71107,9 +71618,15 @@ const _Process = class _Process {
   get stdin() {
     return this._stdin;
   }
+  get stdinIsTTY() {
+    return this._stdinIsTTY;
+  }
   get stdout() {
     return this._stdout;
   }
+  get stdoutIsTTY() {
+    return this._stdoutIsTTY;
+  }
   get terminal() {
     return this._terminal;
   }
@@ -71196,6 +71713,8 @@ const _Process = class _Process {
       shell: this.shell,
       terminal: this.terminal,
       stdin: this._stdin,
+      stdinIsTTY: this._stdinIsTTY,
+      stdoutIsTTY: this._stdoutIsTTY,
       stdout: this._stdout,
       stderr: this._stderr,
       uid: this.uid
@@ -71980,6 +72499,7 @@ const _Shell = class _Shell {
             const isFirstCommand = i === 0;
             const isLastCommand = i === commands.length - 1;
             let inputStream;
+            let stdinIsTTY = false;
             if (isFirstCommand) {
               const inputRedirect = redirections.find((r) => r.type === "<");
               if (inputRedirect) {
@@ -71988,14 +72508,17 @@ const _Shell = class _Shell {
                   throw new Error(`File not found: ${sourcePath}`);
                 }
                 inputStream = this.createFileReadStream(sourcePath, env2, kernel);
+                stdinIsTTY = false;
               } else {
                 inputStream = this._terminal.getInputStream();
+                stdinIsTTY = true;
               }
             } else {
               if (!prevReadable) {
                 throw new Error("Pipeline error: missing previous stream");
               }
               inputStream = prevReadable;
+              stdinIsTTY = false;
             }
             let outputStream;
             let errorStream;
@@ -72065,17 +72588,20 @@ const _Shell = class _Shell {
                 errorStream = this.createTerminalErrorStream();
               }
             }
-            pipelineSetup.push({ finalCommand, args, inputStream, outputStream, errorStream });
+            const stdoutIsTTY = !stdoutRedirect && isLastCommand;
+            pipelineSetup.push({ finalCommand, args, inputStream, stdinIsTTY, outputStream, errorStream, stdoutIsTTY });
           }
           const commandPromises = pipelineSetup.map(
-            ({ finalCommand, args, inputStream, outputStream, errorStream }) => this._kernel.execute({
+            ({ finalCommand, args, inputStream, stdinIsTTY, outputStream, errorStream, stdoutIsTTY }) => this._kernel.execute({
               command: finalCommand,
               args,
               kernel: this._kernel,
               shell: this,
               terminal: this._terminal,
               stdin: inputStream,
+              stdinIsTTY,
               stdout: outputStream,
+              stdoutIsTTY,
               stderr: errorStream
             })
           );
@@ -73894,7 +74420,7 @@ const _Workers = class _Workers {
 };
 __name(_Workers, "Workers");
 let Workers = _Workers;
-const __vite_import_meta_env__ = { "AUTHOR": { "name": "Jay Mathis", "email": "code@mathis.network", "url": "https://github.com/mathiscode" }, "BASE_URL": "/", "DESCRIPTION": "ecmaOS: Micro-kernel and framework for web technologies", "DEV": false, "HOMEPAGE": "https://ecmaos.sh", "KNOWN_ISSUES": ["It's best to stick to Chromium-based browsers for the most features", "Keyboard is broken on mobile; ecmaOS is not mobile-friendly at this time", "Don't expect any sort of POSIX compliance at this stage", "Most commands/devices are very basic implementations, not complete reproductions", "stdin/stdout/stderr streams and redirection can be wonky and don't work everywhere, but are coming along", "CTRL-C will return you to a prompt, but doesn't currently interrupt a process", "Lots of unfinished work; watch your step"], "MODE": "production", "NAME": "@ecmaos/kernel", "PROD": true, "REPOSITORY": "https://github.com/ecmaos/ecmaos", "SSR": false, "TIPS": ["If it ever fails to boot, check your logs, try clearing all data, try incognito mode, or try another browser", "You can run some devices that offer a CLI - e.g. '/dev/battery --help'", "Use the 'install' command to install packages - e.g. 'install @ecmaos-apps/news'", "You can install any NPM package - e.g. 'install jquery'", "Use the 'news' command to see the latest news about ecmaOS", "Type 'ls /bin' to see all built-in commands", "Type 'ls /usr/bin' to see all installed commands", "You can set your environment variables in ~/.env (try setting PROMPT to a PS1-like format)", "You can register and login with a passkey: 'passkey register' and 'passkey list'", "Try 'fetch /xkcd-os.sixel'"], "VERSION": "0.6.5", "VITE_APP_SHOW_DEFAULT_LOGIN": "true", "VITE_BOOT_DISABLE_ISSUES": "true", "VITE_BOOT_DISABLE_LOGO_CONSOLE": "false", "VITE_BOOT_DISABLE_LOGO_FIGLET": "false", "VITE_BOOT_DISABLE_TIPS": "false", "VITE_INITFS": "/initfs.tar.gz", "VITE_KERNEL_INTERVALS_PROC": "1000", "VITE_KERNEL_MODULES": "@ecmaos-modules/boilerplate@0.1.0", "VITE_METAL_SOCKET": "ws://localhost:30445/socket", "VITE_PORT": "30443", "VITE_RECOMMENDED_APPS": "@ecmaos-apps/code,@ecmaos-apps/edit,@ecmaos-apps/ai,@ecmaos-apps/webamp,@ecmaos-apps/news", "XTERM_VERSION": "5.5.0", "ZENFS_VERSION": "2.4.2" };
+const __vite_import_meta_env__ = { "AUTHOR": { "name": "Jay Mathis", "email": "code@mathis.network", "url": "https://github.com/mathiscode" }, "BASE_URL": "/", "DESCRIPTION": "ecmaOS: Micro-kernel and framework for web technologies", "DEV": false, "HOMEPAGE": "https://ecmaos.sh", "KNOWN_ISSUES": ["It's best to stick to Chromium-based browsers for the most features", "Keyboard is broken on mobile; ecmaOS is not mobile-friendly at this time", "Don't expect any sort of POSIX compliance at this stage", "Most commands/devices are very basic implementations, not complete reproductions", "stdin/stdout/stderr streams and redirection can be wonky and don't work everywhere, but are coming along", "CTRL-C will return you to a prompt, but doesn't currently interrupt a process", "Lots of unfinished work; watch your step"], "MODE": "production", "NAME": "@ecmaos/kernel", "PROD": true, "REPOSITORY": "https://github.com/ecmaos/ecmaos", "SSR": false, "TIPS": ["If it ever fails to boot, check your logs, try clearing all data, try incognito mode, or try another browser", "You can run some devices that offer a CLI - e.g. '/dev/battery --help'", "Use the 'install' command to install packages - e.g. 'install @ecmaos-apps/news'", "You can install any NPM package - e.g. 'install jquery'", "Use the 'news' command to see the latest news about ecmaOS", "Type 'ls /bin' to see all built-in commands", "Type 'ls /usr/bin' to see all installed commands", "You can set your environment variables in ~/.env (try setting PROMPT to a PS1-like format)", "You can register and login with a passkey: 'passkey register' and 'passkey list'", "Try 'fetch /xkcd-os.sixel'"], "VERSION": "0.6.6", "VITE_APP_SHOW_DEFAULT_LOGIN": "true", "VITE_AUTOLOGIN_PASSWORD": "root", "VITE_AUTOLOGIN_USERNAME": "root", "VITE_BOOT_DISABLE_ISSUES": "true", "VITE_BOOT_DISABLE_LOGO_CONSOLE": "false", "VITE_BOOT_DISABLE_LOGO_FIGLET": "false", "VITE_BOOT_DISABLE_TIPS": "false", "VITE_INITFS": "/initfs.tar.gz", "VITE_KERNEL_INTERVALS_PROC": "1000", "VITE_KERNEL_MODULES": "@ecmaos-modules/boilerplate@0.1.0", "VITE_METAL_SOCKET": "ws://localhost:30445/socket", "VITE_PORT": "30443", "VITE_RECOMMENDED_APPS": "@ecmaos-apps/code,@ecmaos-apps/edit,@ecmaos-apps/ai,@ecmaos-apps/webamp,@ecmaos-apps/news", "XTERM_VERSION": "5.5.0", "ZENFS_VERSION": "2.4.2" };
 var define_import_meta_env_AUTHOR_default = { name: "Jay Mathis", email: "code@mathis.network", url: "https://github.com/mathiscode" };
 var define_import_meta_env_KNOWN_ISSUES_default = ["It's best to stick to Chromium-based browsers for the most features", "Keyboard is broken on mobile; ecmaOS is not mobile-friendly at this time", "Don't expect any sort of POSIX compliance at this stage", "Most commands/devices are very basic implementations, not complete reproductions", "stdin/stdout/stderr streams and redirection can be wonky and don't work everywhere, but are coming along", "CTRL-C will return you to a prompt, but doesn't currently interrupt a process", "Lots of unfinished work; watch your step"];
 var define_import_meta_env_TIPS_default = ["If it ever fails to boot, check your logs, try clearing all data, try incognito mode, or try another browser", "You can run some devices that offer a CLI - e.g. '/dev/battery --help'", "Use the 'install' command to install packages - e.g. 'install @ecmaos-apps/news'", "You can install any NPM package - e.g. 'install jquery'", "Use the 'news' command to see the latest news about ecmaOS", "Type 'ls /bin' to see all built-in commands", "Type 'ls /usr/bin' to see all installed commands", "You can set your environment variables in ~/.env (try setting PROMPT to a PS1-like format)", "You can register and login with a passkey: 'passkey register' and 'passkey list'", "Try 'fetch /xkcd-os.sixel'"];
@@ -73939,7 +74465,7 @@ const _Kernel = class _Kernel {
     /** Name of the kernel */
     __publicField(this, "name", "@ecmaos/kernel");
     /** Version string of the kernel */
-    __publicField(this, "version", "0.6.5");
+    __publicField(this, "version", "0.6.6");
     /** Authentication and authorization service */
     __publicField(this, "auth");
     /** BIOS module providing low-level functionality */
@@ -74097,7 +74623,7 @@ const _Kernel = class _Kernel {
         ];
         this.terminal.writeln(chalk$2.red.bold(`🐉  ${t2("kernel.experimental", "EXPERIMENTAL")} 🐉`));
         this.terminal.writeln(
-          `${this.terminal.createSpecialLink("https://ecmaos.sh", "@ecmaos/kernel")}@${"0.6.5"}` + chalk$2.cyan(` [${dependencyLinks.map((link2) => link2.link).join(", ")}]`)
+          `${this.terminal.createSpecialLink("https://ecmaos.sh", "@ecmaos/kernel")}@${"0.6.6"}` + chalk$2.cyan(` [${dependencyLinks.map((link2) => link2.link).join(", ")}]`)
         );
         this.terminal.writeln(`${t2("kernel.madeBy", "Made with ❤️  by Jay Mathis")} ${this.terminal.createSpecialLink(
           define_import_meta_env_AUTHOR_default?.url || "https://github.com/mathiscode",
@@ -74114,14 +74640,14 @@ const _Kernel = class _Kernel {
         if (logoFiglet && true) {
           console.log(`%c${logoFiglet}`, "color: green");
           console.log(`%c${"https://github.com/ecmaos/ecmaos"}`, "color: blue; text-decoration: underline; font-size: 16px");
-          this.log.info(`${"@ecmaos/kernel"} v${"0.6.5"}`);
+          this.log.info(`${"@ecmaos/kernel"} v${"0.6.6"}`);
         }
         if (Notification?.permission === "default") Notification.requestPermission();
         if (Notification?.permission === "denied") this.log.warn(t2("kernel.permissionNotificationDenied", "Notification permission denied"));
         this.intervals.set("title-blink", () => {
           globalThis.document.title = globalThis.document.title.includes("_") ? "ecmaos# " : "ecmaos# _";
         }, 600);
-        this.toast.success(`${"@ecmaos/kernel"} v${"0.6.5"}`);
+        this.toast.success(`${"@ecmaos/kernel"} v${"0.6.6"}`);
       }
       await this.configure({ devices: this.options.devices || DefaultDevices, filesystem: Filesystem.options() });
       const requiredPaths = [
@@ -74590,7 +75116,9 @@ const _Kernel = class _Kernel {
       terminal: options.terminal || this.terminal,
       entry: /* @__PURE__ */ __name(async (params) => await command.run.call(params, params.pid, params.args), "entry"),
       stdin: options.stdin,
+      stdinIsTTY: options.stdinIsTTY,
       stdout: options.stdout,
+      stdoutIsTTY: options.stdoutIsTTY,
       stderr: options.stderr
     });
     const exitCode = await process2.start();
@@ -74867,7 +75395,7 @@ const _Kernel = class _Kernel {
       memory: "?",
       platform: navigator.userAgentData?.platform || navigator?.platform || navigator.userAgent,
       querystring: location.search,
-      version: `${"@ecmaos/kernel"} ${"0.6.5"}`,
+      version: `${"@ecmaos/kernel"} ${"0.6.6"}`,
       language: navigator.language,
       host: location.host,
       userAgent: navigator.userAgent,
@@ -75044,4 +75572,4 @@ export {
   path$1 as p,
   semver as s
 };
-//# sourceMappingURL=kernel-C_Xvcpox.js.map
+//# sourceMappingURL=kernel-DZB_DlxI.js.map