@bashlife/boxbox-beta 69.0.0

package/bin/boxbox.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../src/index.js";

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@bashlife/boxbox-beta",
+  "version": "69.0.0",
+  "description": "A modern BusyBox-style CLI toolkit with custom commands.",
+  "type": "module",
+  "author": "bashlife",
+  "bin": {
+    "boxbox": "bin/boxbox.js"
+  },
+  "keywords": [
+    "cli",
+    "busybox",
+    "toolkit",
+    "commands",
+    "unix",
+    "bash",
+    "boxbox"
+  ],
+  "license": "UNLICENSED"
+}

package/src/commands/JavaScriptRun/Loader.js

@@ -0,0 +1,47 @@
+import fs from "fs";
+import vm from "vm";
+import path from "path";
+import { createRequire } from "module";
+
+export function loadCommonJS(entry) {
+  try {
+    const code = fs.readFileSync(entry, "utf8");
+
+    const module = {
+      exports: {}
+    };
+
+    const dirname = path.dirname(entry);
+    const filename = entry;
+
+    const require = createRequire(entry);
+
+    const wrapped = `
+      (function(
+        require,
+        module,
+        exports,
+        __filename,
+        __dirname
+      ) {
+        ${code}
+      });
+    `;
+
+    const script = vm.runInThisContext(wrapped);
+
+    script(
+      require,
+      module,
+      module.exports,
+      filename,
+      dirname
+    );
+
+    return module.exports;
+
+  } catch (err) {
+    console.error(`Loader: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/JavaScriptRun/ModuleLoader.js

@@ -0,0 +1,11 @@
+export async function loadModule(entry) {
+  try {
+    const modulePath = new URL(`file://${entry}`);
+
+    await import(modulePath.href);
+
+  } catch (err) {
+    console.error(`ModuleLoader: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/JavaScriptRun/index.js

@@ -0,0 +1,61 @@
+import fs from "fs";
+import path from "path";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default async function javascriptRun(args) {
+  const command = args[0];
+
+  if (!command) {
+    console.log("javascript: missing command");
+    console.log("Usage: boxbox javascript <init|run>");
+    return;
+  }
+
+  if (command === "init") {
+    const projectRoot = process.cwd();
+
+    const srcDir = path.join(projectRoot, "src");
+    const configPath = path.join(projectRoot, "jsrun.yaml");
+
+    if (!fs.existsSync(srcDir)) {
+      fs.mkdirSync(srcDir, { recursive: true });
+    }
+
+    if (!fs.existsSync(configPath)) {
+      fs.writeFileSync(
+        configPath,
+        `type: module\nentry: app.js\n`
+      );
+    }
+
+    console.log("JavaScriptRun project initialized");
+    console.log("Created:");
+    console.log("  src/");
+    console.log("  jsrun.yaml");
+    return;
+  }
+
+  if (command === "run") {
+    const runtime = path.join(__dirname, "jsRun.js");
+
+    const child = spawn(
+      process.execPath,
+      [runtime],
+      {
+        stdio: "inherit"
+      }
+    );
+
+    child.on("error", err => {
+      console.log(`javascript run error: ${err.message}`);
+    });
+
+    return;
+  }
+
+  console.log(`javascript: unknown command '${command}'`);
+}

package/src/commands/JavaScriptRun/init.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+
+export default function init() {
+  const root = process.cwd();
+
+  const srcDir = path.join(root, "src");
+  const configFile = path.join(root, "jsrun.yaml");
+  const appFile = path.join(root, "app.js");
+
+  if (!fs.existsSync(srcDir)) {
+    fs.mkdirSync(srcDir, { recursive: true });
+  }
+
+  if (!fs.existsSync(configFile)) {
+    fs.writeFileSync(
+      configFile,
+      `type: module\nentry: app.js\n`
+    );
+  }
+
+  if (!fs.existsSync(appFile)) {
+    fs.writeFileSync(
+      appFile,
+      `console.log("Hello from jsRun");\n`
+    );
+  }
+
+  console.log("JavaScriptRun initialized");
+  console.log("Created:");
+  console.log("  src/");
+  console.log("  jsrun.yaml");
+  console.log("  app.js");
+}

package/src/commands/JavaScriptRun/jsRun.js

@@ -0,0 +1,111 @@
+import fs from "fs";
+import path from "path";
+
+import { loadCommonJS } from "./Loader.js";
+import { loadModule } from "./ModuleLoader.js";
+
+function findProjectRoot() {
+  let current = process.cwd();
+
+  while (current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, "jsrun.yaml"))) {
+      return current;
+    }
+
+    current = path.dirname(current);
+  }
+
+  return process.cwd();
+}
+
+function parseYaml(content) {
+  const config = {};
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+
+    const separator = trimmed.indexOf(":");
+
+    if (separator === -1) {
+      continue;
+    }
+
+    const key = trimmed
+      .slice(0, separator)
+      .trim();
+
+    let value = trimmed
+      .slice(separator + 1)
+      .trim();
+
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    config[key] = value;
+  }
+
+  return config;
+}
+
+function readConfig(root) {
+  const configPath = path.join(root, "jsrun.yaml");
+
+  if (!fs.existsSync(configPath)) {
+    throw new Error("jsrun.yaml not found");
+  }
+
+  const content = fs.readFileSync(
+    configPath,
+    "utf8"
+  );
+
+  return parseYaml(content);
+}
+
+async function main() {
+  try {
+    const root = findProjectRoot();
+
+    const config = readConfig(root);
+
+    const entry = path.resolve(
+      root,
+      config.entry || "app.js"
+    );
+
+    if (!fs.existsSync(entry)) {
+      throw new Error(
+        `entry file not found: ${entry}`
+      );
+    }
+
+    const type = config.type || "module";
+
+    if (type === "commonjs") {
+      loadCommonJS(entry);
+    } else if (type === "module") {
+      await loadModule(entry);
+    } else {
+      throw new Error(
+        `unsupported type: ${type}`
+      );
+    }
+
+  } catch (err) {
+    console.error(
+      `jsRun: ${err.message}`
+    );
+
+    process.exit(1);
+  }
+}
+
+main();

package/src/commands/awk.js

@@ -0,0 +1,58 @@
+import fs from "fs";
+
+export default function awk(args) {
+  let separator = /\s+/;
+  let program = null;
+  let file = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-F") {
+      const next = args[i + 1];
+      if (next) {
+        separator = new RegExp(next);
+        i++;
+      }
+    } else if (!program) {
+      program = args[i];
+    } else {
+      file = args[i];
+    }
+  }
+
+  if (!program || !file) {
+    console.log("Usage: awk [-F delimiter] '{print $n}' file");
+    return;
+  }
+
+  if (!fs.existsSync(file)) {
+    console.log(`awk: ${file}: No such file`);
+    return;
+  }
+
+  const text = fs.readFileSync(file, "utf8");
+
+  const match = program.match(/print\s+\$(\d+|0)/);
+
+  if (!match) {
+    console.log("awk: unsupported expression");
+    return;
+  }
+
+  const field = match[1];
+
+  const lines = text.split("\n");
+
+  for (const line of lines) {
+    if (field === "0") {
+      console.log(line);
+      continue;
+    }
+
+    const parts = line.split(separator);
+    const index = Number(field) - 1;
+
+    if (parts[index] !== undefined) {
+      console.log(parts[index]);
+    }
+  }
+}

package/src/commands/basename.js

@@ -0,0 +1,10 @@
+import path from "path";
+
+export default function basename(args) {
+  if (!args[0]) {
+    console.log("basename: missing operand");
+    return;
+  }
+
+  console.log(path.basename(args[0]));
+}

package/src/commands/cal.js

@@ -0,0 +1,33 @@
+export default function cal() {
+  const now = new Date();
+
+  const month = now.getMonth();
+  const year = now.getFullYear();
+
+  const name = now.toLocaleString("en-US", { month: "long" });
+
+  console.log(`     ${name} ${year}`);
+  console.log("Su Mo Tu We Th Fr Sa");
+
+  const first = new Date(year, month, 1).getDay();
+  const days = new Date(year, month + 1, 0).getDate();
+
+  let line = "";
+
+  for (let i = 0; i < first; i++) {
+    line += "   ";
+  }
+
+  for (let day = 1; day <= days; day++) {
+    line += String(day).padStart(2, " ") + " ";
+
+    if ((first + day) % 7 === 0) {
+      console.log(line);
+      line = "";
+    }
+  }
+
+  if (line) {
+    console.log(line);
+  }
+}

package/src/commands/call.js

@@ -0,0 +1,115 @@
+import fs from "fs";
+
+export default async function(args) {
+  let method = null;
+  let url = null;
+  let body = null;
+
+  const headers = {};
+  const formData = new FormData();
+  let hasForm = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === "-H" || arg === "--header") {
+      const header = args[++i];
+
+      if (!header) continue;
+
+      const split = header.indexOf(":");
+
+      if (split !== -1) {
+        const key = header.slice(0, split).trim();
+        const value = header.slice(split + 1).trim();
+
+        headers[key] = value;
+      }
+    }
+
+    else if (arg === "-F" || arg === "--form") {
+      const form = args[++i];
+
+      if (!form) continue;
+
+      hasForm = true;
+
+      const split = form.indexOf("=");
+
+      if (split !== -1) {
+        const name = form.slice(0, split);
+        const value = form.slice(split + 1);
+
+        if (value.startsWith("@")) {
+          const filePath = value.slice(1);
+
+          const file = fs.readFileSync(filePath);
+
+          formData.append(
+            name,
+            new Blob([file]),
+            filePath.split("/").pop()
+          );
+        } else {
+          formData.append(name, value);
+        }
+      }
+    }
+
+    else if (!method) {
+      method = arg.toUpperCase();
+    }
+
+    else if (!url) {
+      url = arg;
+    }
+
+    else if (!body) {
+      body = arg;
+    }
+  }
+
+  if (!method || !url) {
+    console.log(`
+Usage:
+  boxbox call METHOD URL [body]
+
+Options:
+  -H, --header "Name: Value"
+  -F, --form "name=value"
+  -F, --form "file=@path"
+`);
+    return;
+  }
+
+  try {
+    const options = {
+      method,
+      headers
+    };
+
+    if (hasForm) {
+      options.body = formData;
+
+      // Let fetch set multipart boundary automatically
+      delete options.headers["Content-Type"];
+    }
+
+    else if (body && method !== "GET" && method !== "HEAD") {
+      options.body = body;
+
+      if (!options.headers["Content-Type"]) {
+        options.headers["Content-Type"] = "application/json";
+      }
+    }
+
+    const response = await fetch(url, options);
+
+    console.log(`HTTP ${response.status}`);
+
+    console.log(await response.text());
+
+  } catch (err) {
+    console.log(`call: ${err.message}`);
+  }
+}

package/src/commands/cat.js

@@ -0,0 +1,16 @@
+import fs from "fs";
+
+export default function(args) {
+  const file = args[0];
+
+  if (!file) {
+    console.log("Usage: cat <file>");
+    return;
+  }
+
+  try {
+    console.log(fs.readFileSync(file, "utf8"));
+  } catch (err) {
+    console.log(`cat: ${err.message}`);
+  }
+}

package/src/commands/cd.sh

@@ -0,0 +1,12 @@
+boxbox() {
+  if [ "$1" = "cd" ]; then
+    if [ -z "$2" ]; then
+      echo "cd: missing directory"
+      return 1
+    fi
+
+    cd "$2" || echo "Directory not found: $2"
+  else
+    command boxbox "$@"
+  fi
+}

package/src/commands/chmod.js

@@ -0,0 +1,27 @@
+import fs from "fs";
+
+export default function(args) {
+  if (args.length < 2) {
+    console.log("Usage: chmod <mode> <file>");
+    return;
+  }
+
+  const mode = args[0];
+  const file = args[1];
+
+  try {
+    const permissions = parseInt(mode, 8);
+
+    if (isNaN(permissions)) {
+      console.log(`chmod: invalid mode '${mode}'`);
+      return;
+    }
+
+    fs.chmodSync(file, permissions);
+
+    console.log(`Changed permissions of ${file} to ${mode}`);
+
+  } catch (err) {
+    console.log(`chmod: ${err.message}`);
+  }
+}

package/src/commands/clear.js

@@ -0,0 +1,3 @@
+export default function clear() {
+  process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+}

package/src/commands/cp.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+
+export default function(args) {
+  const src = args[0];
+  const dest = args[1];
+
+  if (!src || !dest) {
+    console.log("Usage: cp <source> <destination>");
+    return;
+  }
+
+  try {
+    fs.copyFileSync(src, dest);
+  } catch (err) {
+    console.log(`cp: ${err.message}`);
+  }
+}

package/src/commands/curl.js

@@ -0,0 +1,80 @@
+import fs from "fs";
+import path from "path";
+
+export default async function(args) {
+  let method = "GET";
+  let url = null;
+  let body = null;
+  let outputFile = false;
+  let headers = {
+    "Content-Type": "application/json"
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === "-X" || arg === "--request") {
+      method = args[++i].toUpperCase();
+    }
+
+    else if (arg === "-O") {
+      outputFile = true;
+    }
+
+    else if (arg === "-H" || arg === "--header") {
+      const header = args[++i];
+      const split = header.indexOf(":");
+
+      if (split !== -1) {
+        const key = header.slice(0, split).trim();
+        const value = header.slice(split + 1).trim();
+
+        headers[key] = value;
+      }
+    }
+
+    else if (arg === "-d" || arg === "--data") {
+      body = args[++i];
+    }
+
+    else if (!url) {
+      url = arg;
+    }
+  }
+
+  if (!url) {
+    console.log("Usage: curl [-X METHOD] [-O] [-H header] [-d data] <url>");
+    return;
+  }
+
+  try {
+    const options = {
+      method,
+      headers
+    };
+
+    if (body) {
+      options.body = body;
+    }
+
+    const response = await fetch(url, options);
+
+    console.log(`HTTP ${response.status}`);
+
+    if (outputFile) {
+      const filename = path.basename(new URL(url).pathname) || "download";
+
+      const buffer = Buffer.from(await response.arrayBuffer());
+
+      fs.writeFileSync(filename, buffer);
+
+      console.log(`Saved ${filename}`);
+      return;
+    }
+
+    console.log(await response.text());
+
+  } catch (err) {
+    console.log(`curl: ${err.message}`);
+  }
+}