@lifo-sh/core 0.5.0 → 0.5.6

package/dist/cut-Dg3Sxlw_.js

@@ -0,0 +1,84 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+import { i as isBinaryMime, g as getMimeType } from "./mime-B5knsVEw.js";
+function parseFieldSpec(spec) {
+  const fields = [];
+  for (const part of spec.split(",")) {
+    const rangeParts = part.split("-");
+    if (rangeParts.length === 2) {
+      const start = parseInt(rangeParts[0], 10);
+      const end = parseInt(rangeParts[1], 10);
+      if (!isNaN(start) && !isNaN(end)) {
+        for (let i = start; i <= end; i++) fields.push(i);
+      }
+    } else {
+      const n = parseInt(part, 10);
+      if (!isNaN(n)) fields.push(n);
+    }
+  }
+  return fields;
+}
+const command = async (ctx) => {
+  let delimiter = "	";
+  let fieldSpec = "";
+  const files = [];
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === "-d" && i + 1 < ctx.args.length) {
+      delimiter = ctx.args[++i];
+    } else if (arg === "-f" && i + 1 < ctx.args.length) {
+      fieldSpec = ctx.args[++i];
+    } else if (arg.startsWith("-d") && arg.length > 2) {
+      delimiter = arg.slice(2);
+    } else if (arg.startsWith("-f") && arg.length > 2) {
+      fieldSpec = arg.slice(2);
+    } else {
+      files.push(arg);
+    }
+  }
+  if (!fieldSpec) {
+    ctx.stderr.write("cut: you must specify a list of fields\n");
+    return 1;
+  }
+  const fields = parseFieldSpec(fieldSpec);
+  function cutLine(line) {
+    const parts = line.split(delimiter);
+    return fields.map((f) => parts[f - 1] || "").join(delimiter);
+  }
+  let text = "";
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      text = await ctx.stdin.readAll();
+    } else {
+      ctx.stderr.write("cut: missing file operand\n");
+      return 1;
+    }
+  } else {
+    for (const file of files) {
+      const path = resolve(ctx.cwd, file);
+      try {
+        ctx.vfs.stat(path);
+        if (isBinaryMime(getMimeType(path))) {
+          ctx.stderr.write(`cut: ${file}: binary file, skipping
+`);
+          continue;
+        }
+        text += ctx.vfs.readFileString(path);
+      } catch (e) {
+        if (e instanceof VFSError) {
+          ctx.stderr.write(`cut: ${file}: ${e.message}
+`);
+          return 1;
+        }
+        throw e;
+      }
+    }
+  }
+  const lines = text.replace(/\n$/, "").split("\n");
+  for (const line of lines) {
+    ctx.stdout.write(cutLine(line) + "\n");
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/date-DqL4oCg8.js

@@ -0,0 +1,91 @@
+const DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+const MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function pad(n, len = 2) {
+  return String(n).padStart(len, "0");
+}
+function formatDate(format, d) {
+  let result = "";
+  let i = 0;
+  while (i < format.length) {
+    if (format[i] === "%" && i + 1 < format.length) {
+      i++;
+      switch (format[i]) {
+        case "Y":
+          result += d.getFullYear();
+          break;
+        case "m":
+          result += pad(d.getMonth() + 1);
+          break;
+        case "d":
+          result += pad(d.getDate());
+          break;
+        case "H":
+          result += pad(d.getHours());
+          break;
+        case "M":
+          result += pad(d.getMinutes());
+          break;
+        case "S":
+          result += pad(d.getSeconds());
+          break;
+        case "A":
+          result += DAYS[d.getDay()];
+          break;
+        case "B":
+          result += MONTHS[d.getMonth()];
+          break;
+        case "Z":
+          result += "UTC";
+          break;
+        case "s":
+          result += Math.floor(d.getTime() / 1e3);
+          break;
+        case "p":
+          result += d.getHours() >= 12 ? "PM" : "AM";
+          break;
+        case "I": {
+          const h = d.getHours() % 12;
+          result += pad(h === 0 ? 12 : h);
+          break;
+        }
+        case "%":
+          result += "%";
+          break;
+        default:
+          result += "%" + format[i];
+          break;
+      }
+      i++;
+    } else {
+      result += format[i];
+      i++;
+    }
+  }
+  return result;
+}
+const command = async (ctx) => {
+  const now = /* @__PURE__ */ new Date();
+  if (ctx.args.length > 0 && ctx.args[0].startsWith("+")) {
+    const format = ctx.args[0].slice(1);
+    ctx.stdout.write(formatDate(format, now) + "\n");
+  } else {
+    ctx.stdout.write(now.toString() + "\n");
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/df-CEHqyq91.js

@@ -0,0 +1,47 @@
+function humanSize(bytes) {
+  if (bytes < 1024) return bytes + "B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + "K";
+  if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + "M";
+  return (bytes / (1024 * 1024 * 1024)).toFixed(1) + "G";
+}
+const command = async (ctx) => {
+  let human = false;
+  for (const arg of ctx.args) {
+    if (arg === "-h") human = true;
+  }
+  let totalFiles = 0;
+  let totalBytes = 0;
+  function walk(dirPath) {
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === "/" ? "/" + entry.name : dirPath + "/" + entry.name;
+        if (entry.type === "file") {
+          totalFiles++;
+          const st = ctx.vfs.stat(fullPath);
+          totalBytes += st.size;
+        } else {
+          walk(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  walk("/");
+  const totalSpace = 256 * 1024 * 1024;
+  const used = totalBytes;
+  const avail = totalSpace - used;
+  if (human) {
+    ctx.stdout.write("Filesystem      Size  Used  Avail  Use%  Mounted on\n");
+    ctx.stdout.write(`vfs             ${humanSize(totalSpace)}  ${humanSize(used)}  ${humanSize(avail)}  ${Math.round(used / totalSpace * 100)}%    /
+`);
+  } else {
+    ctx.stdout.write("Filesystem      1K-blocks    Used    Available  Use%  Mounted on\n");
+    ctx.stdout.write(`vfs             ${Math.round(totalSpace / 1024)}    ${Math.round(used / 1024)}    ${Math.round(avail / 1024)}  ${Math.round(used / totalSpace * 100)}%    /
+`);
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/diff-aYLFp43G.js

@@ -0,0 +1,250 @@
+import { p as parseArgs } from "./args-BhoL0JcG.js";
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+import { i as isBinaryMime, g as getMimeType } from "./mime-B5knsVEw.js";
+const spec = {
+  unified: { type: "boolean", short: "u" }
+};
+function computeLCS(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (a[i2 - 1] === b[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const ops = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+      ops.push({ type: "keep", oldLine: a[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      ops.push({ type: "insert", newLine: b[j - 1] });
+      j--;
+    } else {
+      ops.push({ type: "delete", oldLine: a[i - 1] });
+      i--;
+    }
+  }
+  return ops.reverse();
+}
+function formatNormal(ops) {
+  const output = [];
+  let oldIdx = 0;
+  let newIdx = 0;
+  let i = 0;
+  while (i < ops.length) {
+    const op = ops[i];
+    if (op.type === "keep") {
+      oldIdx++;
+      newIdx++;
+      i++;
+      continue;
+    }
+    const delStart = oldIdx;
+    const insStart = newIdx;
+    const delLines = [];
+    const insLines = [];
+    while (i < ops.length && ops[i].type !== "keep") {
+      if (ops[i].type === "delete") {
+        delLines.push(ops[i].oldLine);
+        oldIdx++;
+      } else {
+        insLines.push(ops[i].newLine);
+        newIdx++;
+      }
+      i++;
+    }
+    const delRange = delLines.length === 1 ? `${delStart + 1}` : delLines.length > 0 ? `${delStart + 1},${delStart + delLines.length}` : `${delStart}`;
+    const insRange = insLines.length === 1 ? `${insStart + 1}` : insLines.length > 0 ? `${insStart + 1},${insStart + insLines.length}` : `${insStart}`;
+    if (delLines.length > 0 && insLines.length > 0) {
+      output.push(`${delRange}c${insRange}`);
+      for (const l of delLines) output.push(`< ${l}`);
+      output.push("---");
+      for (const l of insLines) output.push(`> ${l}`);
+    } else if (delLines.length > 0) {
+      output.push(`${delRange}d${insRange}`);
+      for (const l of delLines) output.push(`< ${l}`);
+    } else {
+      output.push(`${delRange}a${insRange}`);
+      for (const l of insLines) output.push(`> ${l}`);
+    }
+  }
+  return output.length > 0 ? output.join("\n") + "\n" : "";
+}
+function formatUnified(ops, file1, file2) {
+  if (ops.every((o) => o.type === "keep")) return "";
+  const annotated = [];
+  let oldIdx = 0, newIdx = 0;
+  for (const op of ops) {
+    if (op.type === "keep") {
+      annotated.push({ type: "keep", line: op.oldLine, oldIdx, newIdx });
+      oldIdx++;
+      newIdx++;
+    } else if (op.type === "delete") {
+      annotated.push({ type: "delete", line: op.oldLine, oldIdx, newIdx });
+      oldIdx++;
+    } else {
+      annotated.push({ type: "insert", line: op.newLine, oldIdx, newIdx });
+      newIdx++;
+    }
+  }
+  const context = 3;
+  const hunks = [];
+  let currentHunk = null;
+  let lastChangeIdx = -Infinity;
+  for (let i = 0; i < annotated.length; i++) {
+    const a = annotated[i];
+    if (a.type !== "keep") {
+      if (!currentHunk || i - lastChangeIdx > context * 2 + 1) {
+        if (currentHunk) {
+          for (let j = lastChangeIdx + 1; j < Math.min(lastChangeIdx + 1 + context, annotated.length); j++) {
+            if (annotated[j].type === "keep") {
+              currentHunk.lines.push(` ${annotated[j].line}`);
+              currentHunk.oldCount++;
+              currentHunk.newCount++;
+            }
+          }
+          hunks.push(currentHunk);
+        }
+        const ctxStart = Math.max(0, i - context);
+        let oStart = 0, nStart = 0;
+        for (let j = 0; j < ctxStart; j++) {
+          if (annotated[j].type !== "insert") oStart++;
+          if (annotated[j].type !== "delete") nStart++;
+        }
+        currentHunk = {
+          oldStart: oStart + 1,
+          newStart: nStart + 1,
+          oldCount: 0,
+          newCount: 0,
+          lines: []
+        };
+        for (let j = ctxStart; j < i; j++) {
+          if (annotated[j].type === "keep") {
+            currentHunk.lines.push(` ${annotated[j].line}`);
+            currentHunk.oldCount++;
+            currentHunk.newCount++;
+          }
+        }
+      } else if (i - lastChangeIdx > 1) {
+        for (let j = lastChangeIdx + 1; j < i; j++) {
+          if (annotated[j].type === "keep") {
+            currentHunk.lines.push(` ${annotated[j].line}`);
+            currentHunk.oldCount++;
+            currentHunk.newCount++;
+          }
+        }
+      }
+      if (a.type === "delete") {
+        currentHunk.lines.push(`-${a.line}`);
+        currentHunk.oldCount++;
+      } else {
+        currentHunk.lines.push(`+${a.line}`);
+        currentHunk.newCount++;
+      }
+      lastChangeIdx = i;
+    }
+  }
+  if (currentHunk) {
+    for (let j = lastChangeIdx + 1; j < Math.min(lastChangeIdx + 1 + context, annotated.length); j++) {
+      if (annotated[j].type === "keep") {
+        currentHunk.lines.push(` ${annotated[j].line}`);
+        currentHunk.oldCount++;
+        currentHunk.newCount++;
+      }
+    }
+    hunks.push(currentHunk);
+  }
+  const output = [];
+  output.push(`--- ${file1}`);
+  output.push(`+++ ${file2}`);
+  for (const hunk of hunks) {
+    output.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`);
+    output.push(...hunk.lines);
+  }
+  return output.join("\n") + "\n";
+}
+const command = async (ctx) => {
+  const { flags, positional } = parseArgs(ctx.args, spec);
+  if (positional.length < 2) {
+    ctx.stderr.write("diff: missing operand\n");
+    return 2;
+  }
+  const file1 = positional[0];
+  const file2 = positional[1];
+  let content1;
+  let content2;
+  const path1 = resolve(ctx.cwd, file1);
+  const path2 = resolve(ctx.cwd, file2);
+  const binary1 = isBinaryMime(getMimeType(path1));
+  const binary2 = isBinaryMime(getMimeType(path2));
+  if (binary1 || binary2) {
+    try {
+      ctx.vfs.stat(path1);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`diff: ${file1}: ${e.message}
+`);
+        return 2;
+      }
+      throw e;
+    }
+    try {
+      ctx.vfs.stat(path2);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`diff: ${file2}: ${e.message}
+`);
+        return 2;
+      }
+      throw e;
+    }
+    ctx.stdout.write(`Binary files ${file1} and ${file2} differ
+`);
+    return 2;
+  }
+  try {
+    content1 = ctx.vfs.readFileString(resolve(ctx.cwd, file1));
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`diff: ${file1}: ${e.message}
+`);
+      return 2;
+    }
+    throw e;
+  }
+  try {
+    content2 = ctx.vfs.readFileString(resolve(ctx.cwd, file2));
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`diff: ${file2}: ${e.message}
+`);
+      return 2;
+    }
+    throw e;
+  }
+  if (content1 === content2) {
+    return 0;
+  }
+  const lines1 = content1.split("\n");
+  const lines2 = content2.split("\n");
+  if (lines1.length > 0 && lines1[lines1.length - 1] === "") lines1.pop();
+  if (lines2.length > 0 && lines2[lines2.length - 1] === "") lines2.pop();
+  const ops = computeLCS(lines1, lines2);
+  if (flags.unified) {
+    ctx.stdout.write(formatUnified(ops, file1, file2));
+  } else {
+    ctx.stdout.write(formatNormal(ops));
+  }
+  return 1;
+};
+export {
+  command as default
+};

package/dist/dig-0_V5UoWW.js

@@ -0,0 +1,91 @@
+const TYPE_MAP = {
+  1: "A",
+  2: "NS",
+  5: "CNAME",
+  6: "SOA",
+  15: "MX",
+  16: "TXT",
+  28: "AAAA"
+};
+const command = async (ctx) => {
+  let queryType = "A";
+  let domain;
+  for (const arg of ctx.args) {
+    if (arg.startsWith("-") || arg.startsWith("+")) continue;
+    const upper = arg.toUpperCase();
+    if (["A", "AAAA", "CNAME", "MX", "NS", "TXT", "SOA"].includes(upper)) {
+      queryType = upper;
+    } else {
+      domain = arg;
+    }
+  }
+  if (!domain) {
+    ctx.stderr.write("dig: missing domain\n");
+    ctx.stderr.write("Usage: dig [type] domain\n");
+    return 1;
+  }
+  const url = `https://dns.google/resolve?name=${encodeURIComponent(domain)}&type=${queryType}`;
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: "application/dns-json" },
+      signal: ctx.signal
+    });
+    if (!response.ok) {
+      ctx.stderr.write(`dig: DNS query failed (HTTP ${response.status})
+`);
+      return 1;
+    }
+    const data = await response.json();
+    ctx.stdout.write(`; <<>> Lifo dig <<>> ${queryType} ${domain}
+`);
+    ctx.stdout.write(`;; Got answer:
+`);
+    ctx.stdout.write(`;; ->>HEADER<<- status: ${data.Status === 0 ? "NOERROR" : "NXDOMAIN"}
+`);
+    ctx.stdout.write(`
+`);
+    if (data.Question && data.Question.length > 0) {
+      ctx.stdout.write(`;; QUESTION SECTION:
+`);
+      for (const q of data.Question) {
+        ctx.stdout.write(`;${q.name}.		IN	${TYPE_MAP[q.type] ?? q.type}
+`);
+      }
+      ctx.stdout.write(`
+`);
+    }
+    if (data.Answer && data.Answer.length > 0) {
+      ctx.stdout.write(`;; ANSWER SECTION:
+`);
+      for (const ans of data.Answer) {
+        const typeName = TYPE_MAP[ans.type] ?? String(ans.type);
+        ctx.stdout.write(`${ans.name}.	${ans.TTL}	IN	${typeName}	${ans.data}
+`);
+      }
+      ctx.stdout.write(`
+`);
+    } else {
+      ctx.stdout.write(`;; No answers found.
+
+`);
+    }
+    ctx.stdout.write(`;; SERVER: dns.google
+`);
+    return 0;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("Failed to fetch") || msg.includes("NetworkError")) {
+      ctx.stderr.write(`dig: connection to DNS server failed
+`);
+      ctx.stderr.write(`Note: This may be a CORS restriction or network issue.
+`);
+    } else {
+      ctx.stderr.write(`dig: ${msg}
+`);
+    }
+    return 1;
+  }
+};
+export {
+  command as default
+};

package/dist/dirname-ByojkmnI.js

@@ -0,0 +1,14 @@
+import { i as dirname } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    ctx.stderr.write("dirname: missing operand\n");
+    return 1;
+  }
+  for (const arg of ctx.args) {
+    ctx.stdout.write(dirname(arg) + "\n");
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/du-feoEC53Q.js

@@ -0,0 +1,89 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+function humanSize(bytes) {
+  if (bytes < 1024) return bytes + "B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + "K";
+  if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + "M";
+  return (bytes / (1024 * 1024 * 1024)).toFixed(1) + "G";
+}
+const command = async (ctx) => {
+  let human = false;
+  let summaryOnly = false;
+  const paths = [];
+  for (const arg of ctx.args) {
+    if (arg === "-h") human = true;
+    else if (arg === "-s") summaryOnly = true;
+    else paths.push(arg);
+  }
+  if (paths.length === 0) paths.push(".");
+  function calcSize(dirPath) {
+    let total = 0;
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === "/" ? "/" + entry.name : dirPath + "/" + entry.name;
+        if (entry.type === "file") {
+          const st = ctx.vfs.stat(fullPath);
+          total += st.size;
+        } else {
+          total += calcSize(fullPath);
+        }
+      }
+    } catch {
+    }
+    return total;
+  }
+  function walkAndPrint(dirPath, name) {
+    let total = 0;
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === "/" ? "/" + entry.name : dirPath + "/" + entry.name;
+        const displayPath = name === "/" ? "/" + entry.name : name + "/" + entry.name;
+        if (entry.type === "file") {
+          const st = ctx.vfs.stat(fullPath);
+          total += st.size;
+        } else {
+          const subSize = walkAndPrint(fullPath, displayPath);
+          total += subSize;
+        }
+      }
+    } catch {
+    }
+    if (!summaryOnly) {
+      const display = human ? humanSize(total) : String(total);
+      ctx.stdout.write(display + "	" + name + "\n");
+    }
+    return total;
+  }
+  let exitCode = 0;
+  for (const p of paths) {
+    const absPath = resolve(ctx.cwd, p);
+    try {
+      const st = ctx.vfs.stat(absPath);
+      if (st.type === "file") {
+        const display = human ? humanSize(st.size) : String(st.size);
+        ctx.stdout.write(display + "	" + p + "\n");
+      } else {
+        if (summaryOnly) {
+          const total = calcSize(absPath);
+          const display = human ? humanSize(total) : String(total);
+          ctx.stdout.write(display + "	" + p + "\n");
+        } else {
+          walkAndPrint(absPath, p);
+        }
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`du: ${p}: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/env-CIcDulqw.js

@@ -0,0 +1,10 @@
+const command = async (ctx) => {
+  for (const [key, value] of Object.entries(ctx.env)) {
+    ctx.stdout.write(`${key}=${value}
+`);
+  }
+  return 0;
+};
+export {
+  command as default
+};