@bashlife/boxbox-beta 69.0.0

package/src/commands/join.js

@@ -0,0 +1,40 @@
+import fs from "fs";
+
+export default function join(args) {
+  if (args.length < 2) {
+    console.log("Usage: join file1 file2");
+    return;
+  }
+
+  const file1 = args[0];
+  const file2 = args[1];
+
+  if (!fs.existsSync(file1) || !fs.existsSync(file2)) {
+    console.log("join: file not found");
+    return;
+  }
+
+  const lines1 = fs.readFileSync(file1, "utf8")
+    .trim()
+    .split("\n");
+
+  const lines2 = fs.readFileSync(file2, "utf8")
+    .trim()
+    .split("\n");
+
+  const map = new Map();
+
+  for (const line of lines2) {
+    const parts = line.split(/\s+/);
+    map.set(parts[0], parts.slice(1).join(" "));
+  }
+
+  for (const line of lines1) {
+    const parts = line.split(/\s+/);
+    const key = parts[0];
+
+    if (map.has(key)) {
+      console.log(`${line} ${map.get(key)}`);
+    }
+  }
+}

package/src/commands/kill.js

@@ -0,0 +1,17 @@
+import process from "process";
+
+export default function(args) {
+  const pid = args[0];
+
+  if (!pid) {
+    console.log("Usage: kill <pid>");
+    return;
+  }
+
+  try {
+    process.kill(Number(pid), "SIGTERM");
+    console.log(`Killed process ${pid}`);
+  } catch (err) {
+    console.log(`kill: ${err.message}`);
+  }
+}

package/src/commands/ln.js

@@ -0,0 +1,33 @@
+import fs from "fs";
+
+export default function ln(args) {
+  if (args.length === 0) {
+    console.log("ln: missing operand");
+    return;
+  }
+
+  let symbolic = false;
+
+  if (args[0] === "-s") {
+    symbolic = true;
+    args.shift();
+  }
+
+  if (args.length < 2) {
+    console.log("ln: missing destination");
+    return;
+  }
+
+  const source = args[0];
+  const destination = args[1];
+
+  try {
+    if (symbolic) {
+      fs.symlinkSync(source, destination);
+    } else {
+      fs.linkSync(source, destination);
+    }
+  } catch (err) {
+    console.log(`ln: ${err.message}`);
+  }
+}

package/src/commands/ls.js

@@ -0,0 +1,8 @@
+import fs from "fs";
+
+export default function () {
+  const files = fs.readdirSync(".");
+  for (const file of files) {
+    console.log(file);
+  }
+}

package/src/commands/mkdir.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+
+export default function(args) {
+  const dir = args[0];
+
+  if (!dir) {
+    console.log("Usage: boxbox mkdir <directory>");
+    return;
+  }
+
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    console.log(`Created ${dir}`);
+  } catch (err) {
+    console.log(`mkdir error: ${err.message}`);
+  }
+}

package/src/commands/mv.js

@@ -0,0 +1,18 @@
+import fs from "fs";
+
+export default function(args) {
+  const source = args[0];
+  const destination = args[1];
+
+  if (!source || !destination) {
+    console.log("Usage: boxbox mv <source> <destination>");
+    return;
+  }
+
+  try {
+    fs.renameSync(source, destination);
+    console.log(`Moved ${source} -> ${destination}`);
+  } catch (err) {
+    console.log(`mv error: ${err.message}`);
+  }
+}

package/src/commands/od.js

@@ -0,0 +1,32 @@
+import fs from "fs";
+
+export default function od(args) {
+  if (!args[0]) {
+    console.log("Usage: od file");
+    return;
+  }
+
+  const file = args[0];
+
+  if (!fs.existsSync(file)) {
+    console.log(`od: ${file}: No such file`);
+    return;
+  }
+
+  const data = fs.readFileSync(file);
+
+  let output = "";
+
+  for (let i = 0; i < data.length; i++) {
+    if (i % 16 === 0) {
+      if (output) console.log(output);
+      output = i.toString(8).padStart(7, "0") + " ";
+    }
+
+    output += data[i].toString(16).padStart(2, "0") + " ";
+  }
+
+  if (output) {
+    console.log(output);
+  }
+}

package/src/commands/paste.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+
+export default function paste(args) {
+  if (args.length < 2) {
+    console.log("Usage: paste file1 file2");
+    return;
+  }
+
+  const files = args;
+
+  const contents = files.map(file => {
+    if (!fs.existsSync(file)) {
+      console.log(`paste: ${file}: No such file`);
+      process.exit(1);
+    }
+
+    return fs.readFileSync(file, "utf8")
+      .trim()
+      .split("\n");
+  });
+
+  const maxLines = Math.max(...contents.map(lines => lines.length));
+
+  for (let i = 0; i < maxLines; i++) {
+    const row = contents.map(lines => lines[i] ?? "");
+    console.log(row.join("\t"));
+  }
+}

package/src/commands/preview.js

@@ -0,0 +1,38 @@
+import { execFile } from "child_process";
+import path from "path";
+
+export default function preview(args) {
+  const input = args[0];
+
+  if (!input) {
+    console.log("Usage: preview <video>");
+    return;
+  }
+
+  const ext = path.extname(input);
+  const output = input.replace(ext, "-preview.png");
+
+  execFile(
+    "ffmpeg",
+    [
+      "-i",
+      input,
+      "-ss",
+      "00:00:01",
+      "-frames:v",
+      "1",
+      "-vf",
+      "scale=1280:720:force_original_aspect_ratio=increase,crop=1280:720",
+      "-y",
+      output
+    ],
+    (error) => {
+      if (error) {
+        console.log(`preview error: ${error.message}`);
+        return;
+      }
+
+      console.log(`Created ${output}`);
+    }
+  );
+}

package/src/commands/printenv.js

@@ -0,0 +1,15 @@
+export default function(args) {
+  if (args[0]) {
+    const value = process.env[args[0]];
+
+    if (value !== undefined) {
+      console.log(value);
+    }
+
+    return;
+  }
+
+  for (const key of Object.keys(process.env)) {
+    console.log(`${key}=${process.env[key]}`);
+  }
+}

package/src/commands/printf.js

@@ -0,0 +1,47 @@
+export default function printf(args) {
+  if (args.length === 0) {
+    return;
+  }
+
+  let color = null;
+  let bold = false;
+  let text = "";
+
+  for (const arg of args) {
+    if (arg.startsWith("color:")) {
+      color = arg.split(":")[1];
+    } else if (arg.startsWith("bold:")) {
+      bold = arg.split(":")[1] === "true";
+    } else if (arg.startsWith("text:")) {
+      text = arg.substring(5);
+    } else {
+      text += (text ? " " : "") + arg;
+    }
+  }
+
+  const colors = {
+    black: "\x1b[30m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m"
+  };
+
+  let output = "";
+
+  if (bold) {
+    output += "\x1b[1m";
+  }
+
+  if (color && colors[color]) {
+    output += colors[color];
+  }
+
+  output += text;
+  output += "\x1b[0m";
+
+  console.log(output);
+}

package/src/commands/ps.js

@@ -0,0 +1,16 @@
+import { exec } from "child_process";
+
+export default function ps() {
+  const command = process.platform === "win32"
+    ? "tasklist"
+    : "ps";
+
+  exec(command, (error, stdout) => {
+    if (error) {
+      console.log(`ps: ${error.message}`);
+      return;
+    }
+
+    console.log(stdout);
+  });
+}

package/src/commands/pwd.js

@@ -0,0 +1,3 @@
+export default function() {
+  console.log(process.cwd());
+}

package/src/commands/readlink.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+
+export default function readlink(args) {
+  if (args.length === 0) {
+    console.log("readlink: missing operand");
+    return;
+  }
+
+  const file = args[0];
+
+  try {
+    const target = fs.readlinkSync(file);
+    console.log(target);
+  } catch (err) {
+    console.log(`readlink: ${file}: ${err.message}`);
+  }
+}

package/src/commands/rm.js

@@ -0,0 +1,60 @@
+import fs from "fs";
+
+export default function(args) {
+  if (args.length === 0) {
+    console.log("Usage: rm [-rf] <file|directory>");
+    return;
+  }
+
+  let recursive = false;
+  let force = false;
+
+  const targets = [];
+
+  for (const arg of args) {
+    if (arg.includes("r")) recursive = true;
+    if (arg.includes("f")) force = true;
+
+    if (!arg.startsWith("-")) {
+      targets.push(arg);
+    }
+  }
+
+  if (targets.length === 0) {
+    console.log("rm: missing operand");
+    return;
+  }
+
+  for (const target of targets) {
+    try {
+      if (!fs.existsSync(target)) {
+        if (!force) {
+          console.log(`rm: ${target}: No such file or directory`);
+        }
+        continue;
+      }
+
+      const stat = fs.statSync(target);
+
+      if (stat.isDirectory()) {
+        if (!recursive) {
+          console.log(`rm: ${target}: is a directory (use -r)`);
+          continue;
+        }
+
+        fs.rmSync(target, {
+          recursive: true,
+          force: true
+        });
+
+      } else {
+        fs.rmSync(target, {
+          force: true
+        });
+      }
+
+    } catch (err) {
+      console.log(`rm: ${err.message}`);
+    }
+  }
+}

package/src/commands/rmdir.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+
+export default function rmdir(args) {
+  const dir = args[0];
+
+  if (!dir) {
+    console.error("rmdir: missing operand");
+    return;
+  }
+
+  try {
+    fs.rmdirSync(dir);
+  } catch (err) {
+    if (err.code === "ENOTEMPTY") {
+      console.error(
+        `rmdir: directory not empty: ${dir}`
+      );
+    } else if (err.code === "ENOENT") {
+      console.error(
+        `rmdir: no such directory: ${dir}`
+      );
+    } else {
+      console.error(
+        `rmdir: ${err.message}`
+      );
+    }
+  }
+}

package/src/commands/sed.js

@@ -0,0 +1,103 @@
+import fs from "fs";
+
+export default function sed(args) {
+  let quiet = false;
+  let expression = null;
+  let file = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-n") {
+      quiet = true;
+    } else if (!expression) {
+      expression = args[i];
+    } else {
+      file = args[i];
+    }
+  }
+
+  let input = "";
+
+  if (file) {
+    if (!fs.existsSync(file)) {
+      console.log(`sed: ${file}: No such file`);
+      return;
+    }
+
+    input = fs.readFileSync(file, "utf8");
+  } else {
+    console.log("sed: stdin mode not supported yet");
+    return;
+  }
+
+  let lines = input.split("\n");
+
+  if (!expression) {
+    console.log("Usage: sed [-n] 'command' file");
+    return;
+  }
+
+  // Support multiple commands separated by ;
+  const commands = expression.split(";");
+
+  for (const cmd of commands) {
+
+    // s/old/new/
+    if (cmd.startsWith("s/")) {
+      const parts = cmd.split("/");
+
+      const oldText = parts[1];
+      const newText = parts[2];
+      const flags = parts[3] || "";
+
+      lines = lines.map(line => {
+        if (flags.includes("g")) {
+          return line.split(oldText).join(newText);
+        }
+
+        return line.replace(oldText, newText);
+      });
+
+      continue;
+    }
+
+    // /pattern/d
+    if (cmd.startsWith("/") && cmd.endsWith("/d")) {
+      const pattern = cmd.slice(1, -2);
+
+      lines = lines.filter(line => !line.includes(pattern));
+
+      continue;
+    }
+
+    // /pattern/p
+    if (cmd.startsWith("/") && cmd.endsWith("/p")) {
+      const pattern = cmd.slice(1, -2);
+
+      lines.forEach(line => {
+        if (line.includes(pattern)) {
+          console.log(line);
+        }
+      });
+
+      return;
+    }
+
+    // line number print: 2p
+    if (cmd.endsWith("p")) {
+      const num = Number(cmd.slice(0, -1));
+
+      if (!isNaN(num) && lines[num - 1]) {
+        console.log(lines[num - 1]);
+      }
+
+      return;
+    }
+
+    console.log(`sed: unsupported command '${cmd}'`);
+    return;
+  }
+
+  if (!quiet) {
+    console.log(lines.join("\n"));
+  }
+}

package/src/commands/seq.js

@@ -0,0 +1,17 @@
+export default function seq(args) {
+  if (!args[0]) {
+    console.log("seq: missing operand");
+    return;
+  }
+
+  const end = Number(args[0]);
+
+  if (!Number.isFinite(end)) {
+    console.log("seq: invalid number");
+    return;
+  }
+
+  for (let i = 1; i <= end; i++) {
+    console.log(i);
+  }
+}

package/src/commands/sleep.js

@@ -0,0 +1,17 @@
+export default async function sleep(args) {
+  if (!args[0]) {
+    console.log("sleep: missing operand");
+    return;
+  }
+
+  const seconds = Number(args[0]);
+
+  if (!Number.isFinite(seconds) || seconds < 0) {
+    console.log("sleep: invalid time");
+    return;
+  }
+
+  await new Promise(resolve =>
+    setTimeout(resolve, seconds * 1000)
+  );
+}

package/src/commands/sort.js

@@ -0,0 +1,24 @@
+import fs from "fs";
+
+export default function(args) {
+  const file = args[0];
+
+  if (!file) {
+    console.log("Usage: sort <file>");
+    return;
+  }
+
+  try {
+    const content = fs.readFileSync(file, "utf8");
+
+    const lines = content
+      .split("\n")
+      .filter(line => line.length > 0)
+      .sort();
+
+    console.log(lines.join("\n"));
+
+  } catch (err) {
+    console.log(`sort: ${err.message}`);
+  }
+}

package/src/commands/split.js

@@ -0,0 +1,30 @@
+import fs from "fs";
+
+export default function split(args) {
+  if (!args[0]) {
+    console.log("Usage: split file");
+    return;
+  }
+
+  const file = args[0];
+
+  if (!fs.existsSync(file)) {
+    console.log(`split: ${file}: No such file`);
+    return;
+  }
+
+  const lines = fs.readFileSync(file, "utf8").split("\n");
+
+  const chunkSize = 1000;
+  let index = 0;
+
+  for (let i = 0; i < lines.length; i += chunkSize) {
+    const chunk = lines.slice(i, i + chunkSize).join("\n");
+    const name = "x" + String.fromCharCode(97 + index);
+
+    fs.writeFileSync(name, chunk);
+    console.log(name);
+
+    index++;
+  }
+}

package/src/commands/strings.js

@@ -0,0 +1,26 @@
+import fs from "fs";
+
+export default function strings(args) {
+  if (!args[0]) {
+    console.log("Usage: strings file");
+    return;
+  }
+
+  const file = args[0];
+
+  if (!fs.existsSync(file)) {
+    console.log(`strings: ${file}: No such file`);
+    return;
+  }
+
+  const data = fs.readFileSync(file);
+  const text = data.toString("utf8");
+
+  const matches = text.match(/[ -~]{4,}/g);
+
+  if (matches) {
+    for (const str of matches) {
+      console.log(str);
+    }
+  }
+}

package/src/commands/tail.js

@@ -0,0 +1,23 @@
+import fs from "fs";
+
+export default function(args) {
+  const file = args[0];
+
+  if (!file) {
+    console.log("Usage: tail <file>");
+    return;
+  }
+
+  try {
+    const content = fs.readFileSync(file, "utf8");
+
+    const lines = content.split("\n");
+
+    const amount = 10;
+
+    console.log(lines.slice(-amount).join("\n"));
+
+  } catch (err) {
+    console.log(`tail: ${err.message}`);
+  }
+}