@lifo-sh/core 0.5.0 → 0.5.6

package/dist/grep-Bv7fu1qw.js

@@ -0,0 +1,179 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+import { i as isBinaryMime, g as getMimeType } from "./mime-B5knsVEw.js";
+const command = async (ctx) => {
+  const args = ctx.args;
+  let ignoreCase = false;
+  let invert = false;
+  let lineNumbers = false;
+  let countOnly = false;
+  let filesWithMatches = false;
+  let recursive = false;
+  let wordMatch = false;
+  let pattern = "";
+  const files = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--") {
+      i++;
+      break;
+    }
+    if (arg.startsWith("-") && arg.length > 1 && arg[1] !== "-") {
+      for (let j = 1; j < arg.length; j++) {
+        switch (arg[j]) {
+          case "i":
+            ignoreCase = true;
+            break;
+          case "v":
+            invert = true;
+            break;
+          case "n":
+            lineNumbers = true;
+            break;
+          case "c":
+            countOnly = true;
+            break;
+          case "l":
+            filesWithMatches = true;
+            break;
+          case "r":
+            recursive = true;
+            break;
+          case "E":
+            break;
+          // JS regex is already ERE
+          case "w":
+            wordMatch = true;
+            break;
+        }
+      }
+      i++;
+    } else if (!pattern) {
+      pattern = arg;
+      i++;
+    } else {
+      break;
+    }
+  }
+  while (i < args.length) {
+    files.push(args[i++]);
+  }
+  if (!pattern) {
+    ctx.stderr.write("grep: missing pattern\n");
+    return 2;
+  }
+  let regexPattern = pattern;
+  if (wordMatch) {
+    regexPattern = `\\b${regexPattern}\\b`;
+  }
+  let regex;
+  try {
+    regex = new RegExp(regexPattern, ignoreCase ? "i" : "");
+  } catch {
+    ctx.stderr.write(`grep: invalid regex: ${pattern}
+`);
+    return 2;
+  }
+  let matched = false;
+  const multiFile = files.length > 1 || recursive;
+  async function grepLines(lines, fileName) {
+    let count = 0;
+    for (let idx = 0; idx < lines.length; idx++) {
+      const line = lines[idx];
+      const matches = regex.test(line);
+      if (matches !== invert) {
+        matched = true;
+        count++;
+        if (filesWithMatches) {
+          if (fileName) ctx.stdout.write(fileName + "\n");
+          return;
+        }
+        if (!countOnly) {
+          let output = "";
+          if (multiFile && fileName) output += fileName + ":";
+          if (lineNumbers) output += idx + 1 + ":";
+          output += line + "\n";
+          ctx.stdout.write(output);
+        }
+      }
+    }
+    if (countOnly) {
+      let output = "";
+      if (multiFile && fileName) output += fileName + ":";
+      output += count + "\n";
+      ctx.stdout.write(output);
+    }
+  }
+  function walkDir(dirPath) {
+    const result = [];
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === "/" ? "/" + entry.name : dirPath + "/" + entry.name;
+        if (entry.type === "file") {
+          result.push(fullPath);
+        } else if (entry.type === "directory") {
+          result.push(...walkDir(fullPath));
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      const content = await ctx.stdin.readAll();
+      const lines = content.replace(/\n$/, "").split("\n");
+      await grepLines(lines, null);
+    } else {
+      ctx.stderr.write("grep: missing file operand\n");
+      return 2;
+    }
+  } else {
+    for (const file of files) {
+      const path = resolve(ctx.cwd, file);
+      try {
+        const stat = ctx.vfs.stat(path);
+        if (stat.type === "directory") {
+          if (recursive) {
+            const dirFiles = walkDir(path);
+            for (const f of dirFiles) {
+              try {
+                if (isBinaryMime(getMimeType(f))) {
+                  continue;
+                }
+                const content2 = ctx.vfs.readFileString(f);
+                const lines2 = content2.replace(/\n$/, "").split("\n");
+                await grepLines(lines2, f);
+              } catch {
+              }
+            }
+          } else {
+            ctx.stderr.write(`grep: ${file}: Is a directory
+`);
+          }
+          continue;
+        }
+        if (isBinaryMime(getMimeType(path))) {
+          ctx.stderr.write(`grep: ${file}: binary file, skipping
+`);
+          continue;
+        }
+        const content = ctx.vfs.readFileString(path);
+        const lines = content.replace(/\n$/, "").split("\n");
+        await grepLines(lines, multiFile ? file : null);
+      } catch (e) {
+        if (e instanceof VFSError) {
+          ctx.stderr.write(`grep: ${file}: ${e.message}
+`);
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+  return matched ? 0 : 1;
+};
+export {
+  command as default
+};

package/dist/gunzip-BZk2000a.js

@@ -0,0 +1,57 @@
+import { r as resolve, h as decompressGzip, V as VFSError } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  let keep = false;
+  const files = [];
+  for (const arg of ctx.args) {
+    switch (arg) {
+      case "-k":
+      case "--keep":
+        keep = true;
+        break;
+      case "--help":
+        ctx.stdout.write("Usage: gunzip [-k] file.gz\n");
+        ctx.stdout.write("  -k, --keep   keep original file\n");
+        return 0;
+      default:
+        if (arg.startsWith("-")) {
+          ctx.stderr.write(`gunzip: unknown option: ${arg}
+`);
+          return 1;
+        }
+        files.push(arg);
+    }
+  }
+  if (files.length === 0) {
+    ctx.stderr.write("gunzip: missing file operand\n");
+    return 1;
+  }
+  let exitCode = 0;
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      if (!path.endsWith(".gz")) {
+        ctx.stderr.write(`gunzip: ${file}: unknown suffix -- ignored
+`);
+        exitCode = 1;
+        continue;
+      }
+      const data = ctx.vfs.readFile(path);
+      const decompressed = await decompressGzip(data);
+      const outPath = path.slice(0, -3);
+      ctx.vfs.writeFile(outPath, decompressed);
+      if (!keep) ctx.vfs.unlink(path);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`gunzip: ${file}: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/gzip-D55LwDu8.js

@@ -0,0 +1,70 @@
+import { r as resolve, h as decompressGzip, f as compressGzip, V as VFSError } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  let keep = false;
+  let decompress = false;
+  const files = [];
+  for (const arg of ctx.args) {
+    switch (arg) {
+      case "-k":
+      case "--keep":
+        keep = true;
+        break;
+      case "-d":
+      case "--decompress":
+        decompress = true;
+        break;
+      case "--help":
+        ctx.stdout.write("Usage: gzip [-k] [-d] file\n");
+        ctx.stdout.write("  -k, --keep         keep original file\n");
+        ctx.stdout.write("  -d, --decompress   decompress\n");
+        return 0;
+      default:
+        if (arg.startsWith("-")) {
+          ctx.stderr.write(`gzip: unknown option: ${arg}
+`);
+          return 1;
+        }
+        files.push(arg);
+    }
+  }
+  if (files.length === 0) {
+    ctx.stderr.write("gzip: missing file operand\n");
+    return 1;
+  }
+  let exitCode = 0;
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      if (decompress) {
+        if (!path.endsWith(".gz")) {
+          ctx.stderr.write(`gzip: ${file}: unknown suffix -- ignored
+`);
+          exitCode = 1;
+          continue;
+        }
+        const data = ctx.vfs.readFile(path);
+        const decompressed = await decompressGzip(data);
+        const outPath = path.slice(0, -3);
+        ctx.vfs.writeFile(outPath, decompressed);
+        if (!keep) ctx.vfs.unlink(path);
+      } else {
+        const data = ctx.vfs.readFile(path);
+        const compressed = await compressGzip(data);
+        ctx.vfs.writeFile(path + ".gz", compressed);
+        if (!keep) ctx.vfs.unlink(path);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`gzip: ${file}: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/head-CQQ8pAha.js

@@ -0,0 +1,66 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+import { i as isBinaryMime, g as getMimeType } from "./mime-B5knsVEw.js";
+const command = async (ctx) => {
+  let count = 10;
+  const files = [];
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === "-n" && i + 1 < ctx.args.length) {
+      count = parseInt(ctx.args[++i], 10);
+      if (isNaN(count)) {
+        ctx.stderr.write("head: invalid number of lines\n");
+        return 1;
+      }
+    } else if (/^-\d+$/.test(arg)) {
+      count = parseInt(arg.slice(1), 10);
+    } else {
+      files.push(arg);
+    }
+  }
+  async function headText(text) {
+    const lines = text.split("\n");
+    const selected = lines.slice(0, count);
+    let output = selected.join("\n");
+    if (lines.length > count) {
+      output += "\n";
+    }
+    ctx.stdout.write(output);
+  }
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      await headText(await ctx.stdin.readAll());
+    } else {
+      ctx.stderr.write("head: missing file operand\n");
+      return 1;
+    }
+    return 0;
+  }
+  let exitCode = 0;
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      ctx.vfs.stat(path);
+      if (isBinaryMime(getMimeType(path))) {
+        ctx.stderr.write(`head: ${file}: binary file, skipping
+`);
+        continue;
+      }
+      const content = ctx.vfs.readFileString(path);
+      if (files.length > 1) ctx.stdout.write(`==> ${file} <==
+`);
+      await headText(content);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`head: ${file}: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/hostname-Ba0tnCzG.js

@@ -0,0 +1,8 @@
+const command = async (ctx) => {
+  const hostname = ctx.env.HOSTNAME || "lifo";
+  ctx.stdout.write(hostname + "\n");
+  return 0;
+};
+export {
+  command as default
+};