@lifo-sh/core 0.5.0 → 0.5.6

package/dist/fastfetch-CRfsfb4t.js

@@ -0,0 +1,378 @@
+const ESC = "\x1B[";
+const RST = `${ESC}0m`;
+const BOLD = `${ESC}1m`;
+function fg(code) {
+  return `${ESC}38;5;${code}m`;
+}
+function bg(code) {
+  return `${ESC}48;5;${code}m`;
+}
+function rgb(r, g, b) {
+  return `${ESC}38;2;${r};${g};${b}m`;
+}
+const COLOR_MAP = {
+  black: fg(0),
+  red: fg(1),
+  green: fg(2),
+  yellow: fg(3),
+  blue: fg(4),
+  magenta: fg(5),
+  cyan: fg(6),
+  white: fg(7),
+  brightblack: fg(8),
+  brightred: fg(9),
+  brightgreen: fg(10),
+  brightyellow: fg(11),
+  brightblue: fg(12),
+  brightmagenta: fg(13),
+  brightcyan: fg(14),
+  brightwhite: fg(15)
+};
+function resolveColor(name) {
+  if (COLOR_MAP[name]) return COLOR_MAP[name];
+  const n = parseInt(name, 10);
+  if (!isNaN(n) && n >= 0 && n <= 255) return fg(n);
+  return fg(14);
+}
+function buildDefaultLogo(accent) {
+  const a = accent;
+  const c1 = rgb(80, 200, 255);
+  const c2 = rgb(60, 160, 240);
+  const c3 = rgb(100, 120, 255);
+  const c4 = rgb(160, 100, 255);
+  const d = fg(8);
+  const lines = [
+    `${a}          ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄${RST}`,
+    `${a}       ▄██${c1}▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀${a}██▄${RST}`,
+    `${a}     ▄██${c1}▀                     ${a}██▄${RST}`,
+    `${a}    ██${c1}▀  ${c1}██      ▀  ████  ████  ${a}██${RST}`,
+    `${a}    ██${c2}   ${c2}██      █  █▀    █  █  ${a}██${RST}`,
+    `${a}    ██${c3}   ${c3}██      █  ███   █  █  ${a}██${RST}`,
+    `${a}    ██${c3}   ${c3}██      █  █▄    █  █  ${a}██${RST}`,
+    `${a}    ██${c4}   ${c4}██████  █  ██    ████  ${a}██${RST}`,
+    `${a}     ▀██${c4}▄                     ${a}██▀${RST}`,
+    `${a}       ▀██${c4}▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄${a}██▀${RST}`,
+    `${a}          ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀${RST}`,
+    `${d}            the browser is the${RST}`,
+    `${d}                  kernel${RST}`
+  ];
+  return { lines, width: 38 };
+}
+function buildSmallLogo(accent) {
+  const a = accent;
+  const lines = [
+    `${a}   ▗▖    ▀  ▗▀▀  ▗▀▀▖${RST}`,
+    `${a}   ▐▌    █  ▐▀   ▐  ▐${RST}`,
+    `${a}   ▐▙▄▖  █  ▐    ▝▀▀▘${RST}`
+  ];
+  return { lines, width: 24 };
+}
+function buildNoneLogo() {
+  return { lines: [], width: 0 };
+}
+function buildCustomLogo(raw, accent) {
+  const lines = raw.split("\n").map((l) => `${accent}${l}${RST}`);
+  let maxWidth = 0;
+  for (const l of raw.split("\n")) {
+    if (l.length > maxWidth) maxWidth = l.length;
+  }
+  return { lines, width: maxWidth + 2 };
+}
+const DEFAULT_CONFIG = {
+  logo: "default",
+  color: "brightcyan",
+  separator: "",
+  modules: [
+    "title",
+    "separator",
+    "os",
+    "host",
+    "kernel",
+    "uptime",
+    "packages",
+    "shell",
+    "terminal",
+    "cpu",
+    "memory",
+    "disk",
+    "locale",
+    "break",
+    "colors"
+  ]
+};
+function loadConfig(vfs) {
+  const paths = [
+    "/home/user/.config/fastfetch/config.json",
+    "/home/user/.fastfetchrc"
+  ];
+  for (const p of paths) {
+    try {
+      const raw = vfs.readFileString(p);
+      const parsed = JSON.parse(raw);
+      return {
+        logo: parsed.logo ?? DEFAULT_CONFIG.logo,
+        color: parsed.color ?? DEFAULT_CONFIG.color,
+        separator: parsed.separator ?? DEFAULT_CONFIG.separator,
+        modules: Array.isArray(parsed.modules) ? parsed.modules : DEFAULT_CONFIG.modules
+      };
+    } catch {
+    }
+  }
+  return DEFAULT_CONFIG;
+}
+function formatUptime() {
+  const ms = performance.now();
+  const totalSeconds = Math.floor(ms / 1e3);
+  const days = Math.floor(totalSeconds / 86400);
+  const hours = Math.floor(totalSeconds % 86400 / 3600);
+  const mins = Math.floor(totalSeconds % 3600 / 60);
+  const parts = [];
+  if (days > 0) parts.push(`${days} day${days !== 1 ? "s" : ""}`);
+  if (hours > 0) parts.push(`${hours} hour${hours !== 1 ? "s" : ""}`);
+  parts.push(`${mins} min${mins !== 1 ? "s" : ""}`);
+  return parts.join(", ");
+}
+function humanSize(bytes) {
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " KiB";
+  if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + " MiB";
+  return (bytes / (1024 * 1024 * 1024)).toFixed(2) + " GiB";
+}
+function getMemoryInfo() {
+  const perf = performance;
+  if (perf.memory) {
+    const used = perf.memory.usedJSHeapSize;
+    const total = perf.memory.jsHeapSizeLimit;
+    const pct = Math.round(used / total * 100);
+    return `${humanSize(used)} / ${humanSize(total)} (${pct}%)`;
+  }
+  return "N/A";
+}
+function getDiskInfo(vfs) {
+  let totalBytes = 0;
+  let totalFiles = 0;
+  function walk(dir) {
+    try {
+      for (const entry of vfs.readdir(dir)) {
+        const full = dir === "/" ? "/" + entry.name : dir + "/" + entry.name;
+        if (entry.type === "file") {
+          totalFiles++;
+          totalBytes += vfs.stat(full).size;
+        } else {
+          walk(full);
+        }
+      }
+    } catch {
+    }
+  }
+  walk("/");
+  const totalSpace = 256 * 1024 * 1024;
+  return `${humanSize(totalBytes)} / ${humanSize(totalSpace)} (${totalFiles} files)`;
+}
+function getBrowser() {
+  if (typeof navigator === "undefined") return "Unknown";
+  const ua = navigator.userAgent;
+  if (ua.includes("Firefox/")) {
+    const m = ua.match(/Firefox\/([\d.]+)/);
+    return m ? `Firefox ${m[1]}` : "Firefox";
+  }
+  if (ua.includes("Edg/")) {
+    const m = ua.match(/Edg\/([\d.]+)/);
+    return m ? `Edge ${m[1]}` : "Edge";
+  }
+  if (ua.includes("Chrome/")) {
+    const m = ua.match(/Chrome\/([\d.]+)/);
+    return m ? `Chrome ${m[1]}` : "Chrome";
+  }
+  if (ua.includes("Safari/")) {
+    const m = ua.match(/Version\/([\d.]+)/);
+    return m ? `Safari ${m[1]}` : "Safari";
+  }
+  return "Unknown";
+}
+function getPlatform() {
+  if (typeof navigator === "undefined") return "Unknown";
+  const ua = navigator.userAgent;
+  if (ua.includes("Mac OS X")) {
+    const m = ua.match(/Mac OS X ([\d_]+)/);
+    return m ? `macOS ${m[1].replace(/_/g, ".")}` : "macOS";
+  }
+  if (ua.includes("Windows NT")) {
+    const m = ua.match(/Windows NT ([\d.]+)/);
+    const ver = m ? m[1] : "";
+    if (ver === "10.0") return "Windows 10+";
+    return `Windows NT ${ver}`;
+  }
+  if (ua.includes("Linux")) return "Linux";
+  if (ua.includes("Android")) return "Android";
+  if (ua.includes("iPhone") || ua.includes("iPad")) return "iOS";
+  return "Unknown";
+}
+function getCPU() {
+  if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) {
+    return `${navigator.hardwareConcurrency} cores`;
+  }
+  return "N/A";
+}
+function getLocale() {
+  if (typeof navigator !== "undefined" && navigator.language) {
+    return navigator.language;
+  }
+  return "en-US";
+}
+function getBinCount(vfs) {
+  try {
+    return vfs.readdir("/bin").length + 20;
+  } catch {
+    return 80;
+  }
+}
+function colorBlocks() {
+  let normal = "";
+  let bright = "";
+  for (let i = 0; i < 8; i++) normal += `${bg(i)}   ${RST}`;
+  for (let i = 8; i < 16; i++) bright += `${bg(i)}   ${RST}`;
+  return [normal, bright];
+}
+function resolveModule(mod, ctx, labelColor, separator) {
+  const lbl = (s, width) => `${BOLD}${labelColor}${s.padEnd(width)}${RST}${separator}`;
+  const W = 10;
+  switch (mod) {
+    case "title":
+      return `${BOLD}${labelColor}${ctx.user}${RST}@${BOLD}${labelColor}${ctx.hostname}${RST}`;
+    case "separator":
+      return `${fg(8)}${"─".repeat(ctx.user.length + 1 + ctx.hostname.length)}${RST}`;
+    case "os":
+      return `${lbl("OS", W)}Lifo 1.0.0 (wasm)`;
+    case "host":
+      return `${lbl("Host", W)}${getBrowser()} on ${getPlatform()}`;
+    case "kernel":
+      return `${lbl("Kernel", W)}Lifo vfs+shell 1.0.0`;
+    case "uptime":
+      return `${lbl("Uptime", W)}${formatUptime()}`;
+    case "packages":
+      return `${lbl("Packages", W)}${getBinCount(ctx.vfs)} (builtins + commands)`;
+    case "shell":
+      return `${lbl("Shell", W)}lifo-sh`;
+    case "terminal":
+      return `${lbl("Terminal", W)}xterm.js (${ctx.cols}x${ctx.rows})`;
+    case "cpu":
+      return `${lbl("CPU", W)}${getCPU()}`;
+    case "memory":
+      return `${lbl("Memory", W)}${getMemoryInfo()}`;
+    case "disk": {
+      return `${lbl("Disk (/)", W)}${getDiskInfo(ctx.vfs)}`;
+    }
+    case "locale":
+      return `${lbl("Locale", W)}${getLocale()}`;
+    case "colors": {
+      const [n, b] = colorBlocks();
+      return n + "\n" + b;
+    }
+    case "break":
+      return "";
+    default:
+      return null;
+  }
+}
+const command = async (ctx) => {
+  const config = loadConfig(ctx.vfs);
+  if (ctx.args.includes("--help") || ctx.args.includes("-h")) {
+    ctx.stdout.write(`Usage: fastfetch [--logo default|small|none] [--color COLOR]
+
+Config file: ~/.config/fastfetch/config.json
+
+Example config:
+{
+  "logo": "default",
+  "color": "brightcyan",
+  "separator": "",
+  "modules": [
+    "title", "separator", "os", "host", "kernel",
+    "uptime", "packages", "shell", "terminal",
+    "cpu", "memory", "disk", "locale",
+    "break", "colors"
+  ]
+}
+
+Available modules:
+  title, separator, os, host, kernel, uptime, packages,
+  shell, terminal, cpu, memory, disk, locale, colors, break
+
+Available logos: default, small, none (or put custom ASCII in config)
+
+Colors: black, red, green, yellow, blue, magenta, cyan, white,
+        brightblack, brightred, brightgreen, brightyellow,
+        brightblue, brightmagenta, brightcyan, brightwhite,
+        or a number 0-255 for 256-color palette
+`);
+    return 0;
+  }
+  let logoChoice = config.logo;
+  let colorChoice = config.color;
+  for (let i = 0; i < ctx.args.length; i++) {
+    if ((ctx.args[i] === "--logo" || ctx.args[i] === "-l") && i + 1 < ctx.args.length) {
+      logoChoice = ctx.args[++i];
+    }
+    if ((ctx.args[i] === "--color" || ctx.args[i] === "-c") && i + 1 < ctx.args.length) {
+      colorChoice = ctx.args[++i];
+    }
+  }
+  const isKnownColor = COLOR_MAP[colorChoice] !== void 0 || !isNaN(parseInt(colorChoice, 10)) && parseInt(colorChoice, 10) >= 0 && parseInt(colorChoice, 10) <= 255;
+  if (!isKnownColor) {
+    ctx.stderr.write(`fastfetch: unknown color '${colorChoice}', using default (brightcyan)
+`);
+  }
+  const accent = resolveColor(colorChoice);
+  let logo;
+  if (logoChoice === "default") {
+    logo = buildDefaultLogo(accent);
+  } else if (logoChoice === "small") {
+    logo = buildSmallLogo(accent);
+  } else if (logoChoice === "none") {
+    logo = buildNoneLogo();
+  } else {
+    try {
+      const raw = ctx.vfs.readFileString(logoChoice);
+      logo = buildCustomLogo(raw, accent);
+    } catch {
+      logo = buildDefaultLogo(accent);
+    }
+  }
+  const user = ctx.env.USER || "user";
+  const hostname = ctx.env.HOSTNAME || "lifo";
+  const cols = parseInt(ctx.env["COLUMNS"] || "80", 10);
+  const rows = parseInt(ctx.env["LINES"] || "24", 10);
+  const modCtx = { user, hostname, cols, rows, vfs: ctx.vfs };
+  const infoLines = [];
+  for (const mod of config.modules) {
+    const result = resolveModule(mod, modCtx, accent, config.separator);
+    if (result !== null) {
+      for (const line of result.split("\n")) {
+        infoLines.push(line);
+      }
+    }
+  }
+  const maxLines = Math.max(logo.lines.length, infoLines.length);
+  let output = "\n";
+  const gap = "  ";
+  for (let i = 0; i < maxLines; i++) {
+    const logoLine = i < logo.lines.length ? logo.lines[i] : "";
+    const infoLine = i < infoLines.length ? infoLines[i] : "";
+    if (logo.width > 0) {
+      if (i < logo.lines.length) {
+        output += logoLine + gap + infoLine + "\n";
+      } else {
+        output += " ".repeat(logo.width) + gap + infoLine + "\n";
+      }
+    } else {
+      output += infoLine + "\n";
+    }
+  }
+  output += "\n";
+  ctx.stdout.write(output);
+  return 0;
+};
+export {
+  command as default
+};

package/dist/file-BHHCgjt9.js

@@ -0,0 +1,79 @@
+import { r as resolve, e as extname, V as VFSError } from "./index-GLjTMF7C.js";
+const extTypes = {
+  ".txt": "ASCII text",
+  ".md": "Markdown text",
+  ".js": "JavaScript source",
+  ".ts": "TypeScript source",
+  ".json": "JSON data",
+  ".html": "HTML document",
+  ".css": "CSS stylesheet",
+  ".sh": "Shell script",
+  ".py": "Python script",
+  ".xml": "XML document",
+  ".yaml": "YAML data",
+  ".yml": "YAML data",
+  ".csv": "CSV data",
+  ".svg": "SVG image",
+  ".png": "PNG image data",
+  ".jpg": "JPEG image data",
+  ".gif": "GIF image data"
+};
+function isText(data) {
+  for (let i = 0; i < Math.min(data.length, 512); i++) {
+    const b = data[i];
+    if (b === 9 || b === 10 || b === 13) continue;
+    if (b >= 32 && b <= 126) continue;
+    if (b >= 128) continue;
+    return false;
+  }
+  return true;
+}
+const command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    ctx.stderr.write("file: missing operand\n");
+    return 1;
+  }
+  let exitCode = 0;
+  for (const arg of ctx.args) {
+    const path = resolve(ctx.cwd, arg);
+    try {
+      const st = ctx.vfs.stat(path);
+      if (st.type === "directory") {
+        ctx.stdout.write(`${arg}: directory
+`);
+        continue;
+      }
+      if (st.size === 0) {
+        ctx.stdout.write(`${arg}: empty
+`);
+        continue;
+      }
+      const ext = extname(arg);
+      if (ext && extTypes[ext]) {
+        ctx.stdout.write(`${arg}: ${extTypes[ext]}
+`);
+        continue;
+      }
+      const data = ctx.vfs.readFile(path);
+      if (isText(data)) {
+        ctx.stdout.write(`${arg}: ASCII text
+`);
+      } else {
+        ctx.stdout.write(`${arg}: data
+`);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`file: ${arg}: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/find-C-pGJyTZ.js

@@ -0,0 +1,63 @@
+import { r as resolve, V as VFSError, g as globMatch } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  let searchPath = ".";
+  let namePattern = "";
+  let typeFilter = "";
+  let maxDepth = Infinity;
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === "-name" && i + 1 < ctx.args.length) {
+      namePattern = ctx.args[++i];
+    } else if (arg === "-type" && i + 1 < ctx.args.length) {
+      typeFilter = ctx.args[++i];
+    } else if (arg === "-maxdepth" && i + 1 < ctx.args.length) {
+      maxDepth = parseInt(ctx.args[++i], 10);
+    } else if (!arg.startsWith("-")) {
+      searchPath = arg;
+    }
+  }
+  const absPath = resolve(ctx.cwd, searchPath);
+  function walk(dirPath, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === "/" ? "/" + entry.name : dirPath + "/" + entry.name;
+        let matches = true;
+        if (namePattern) {
+          matches = globMatch(namePattern, entry.name);
+        }
+        if (typeFilter) {
+          if (typeFilter === "f" && entry.type !== "file") matches = false;
+          if (typeFilter === "d" && entry.type !== "directory") matches = false;
+        }
+        if (matches) {
+          ctx.stdout.write(fullPath + "\n");
+        }
+        if (entry.type === "directory") {
+          walk(fullPath, depth + 1);
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const stat = ctx.vfs.stat(absPath);
+    if (stat.type !== "directory") {
+      ctx.stdout.write(absPath + "\n");
+      return 0;
+    }
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`find: '${searchPath}': ${e.message}
+`);
+      return 1;
+    }
+    throw e;
+  }
+  walk(absPath, 1);
+  return 0;
+};
+export {
+  command as default
+};

package/dist/free-DCkGta9v.js

@@ -0,0 +1,33 @@
+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;
+  }
+  const perf = performance;
+  if (perf.memory) {
+    const total = perf.memory.jsHeapSizeLimit;
+    const used = perf.memory.usedJSHeapSize;
+    const free = total - used;
+    if (human) {
+      ctx.stdout.write("              total        used        free\n");
+      ctx.stdout.write(`Mem:     ${humanSize(total).padStart(10)}  ${humanSize(used).padStart(10)}  ${humanSize(free).padStart(10)}
+`);
+    } else {
+      ctx.stdout.write("              total        used        free\n");
+      ctx.stdout.write(`Mem:     ${String(total).padStart(10)}  ${String(used).padStart(10)}  ${String(free).padStart(10)}
+`);
+    }
+  } else {
+    ctx.stdout.write("Memory information not available in this browser\n");
+  }
+  return 0;
+};
+export {
+  command as default
+};