@scelar/nodepod 1.0.0

package/src/shell/commands/shell-env.ts

@@ -0,0 +1,352 @@
+import type { BuiltinFn, ShellContext } from "../shell-types";
+import {
+  ok,
+  fail,
+  EXIT_FAIL,
+  resolvePath,
+  parseArgs,
+  pathModule,
+  MONTHS_SHORT,
+  MONTHS_LONG,
+  DAYS_SHORT,
+  DAYS_LONG,
+} from "../shell-helpers";
+
+// set by the registry so `which` and `type` can check builtins
+let _builtins: Map<string, BuiltinFn> | null = null;
+
+export function setBuiltinsRef(b: Map<string, BuiltinFn>): void {
+  _builtins = b;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Commands                                                           */
+/* ------------------------------------------------------------------ */
+
+const exportCmd: BuiltinFn = (args, ctx) => {
+  if (args.length === 0) {
+    let out = "";
+    for (const [k, v] of Object.entries(ctx.env)) {
+      out += `declare -x ${k}="${v}"\n`;
+    }
+    return ok(out);
+  }
+  for (const arg of args) {
+    const eq = arg.indexOf("=");
+    if (eq > 0) {
+      ctx.env[arg.slice(0, eq)] = arg.slice(eq + 1);
+    }
+  }
+  return ok();
+};
+
+const unset: BuiltinFn = (args, ctx) => {
+  for (const name of args) delete ctx.env[name];
+  return ok();
+};
+
+const envCmd: BuiltinFn = (_args, ctx) => {
+  let out = "";
+  for (const [k, v] of Object.entries(ctx.env)) out += `${k}=${v}\n`;
+  return ok(out);
+};
+
+const which: BuiltinFn = (args, ctx) => {
+  if (args.length === 0) return fail("which: missing argument\n");
+
+  const { flags } = parseArgs(args, ["a"]);
+  const showAll = flags.has("a");
+  const names = args.filter((a) => !a.startsWith("-"));
+
+  let out = "";
+  for (const name of names) {
+    const found: string[] = [];
+
+    if (_builtins?.has(name)) found.push(`${name}: shell built-in command`);
+
+    const knownBins: Record<string, string> = {
+      node: "/usr/local/bin/node",
+      npm: "/usr/local/bin/npm",
+      npx: "/usr/local/bin/npx",
+      pnpm: "/usr/local/bin/pnpm",
+      yarn: "/usr/local/bin/yarn",
+      bun: "/usr/local/bin/bun",
+      bunx: "/usr/local/bin/bunx",
+    };
+    if (knownBins[name]) found.push(knownBins[name]);
+
+    const binPath = `/node_modules/.bin/${name}`;
+    if (ctx.volume.existsSync(binPath)) found.push(binPath);
+
+    const pathDirs = (ctx.env.PATH || "").split(":").filter(Boolean);
+    for (const dir of pathDirs) {
+      const candidate = `${dir}/${name}`;
+      if (ctx.volume.existsSync(candidate)) {
+        if (!found.includes(candidate)) found.push(candidate);
+      }
+    }
+
+    if (found.length === 0) {
+      out += `${name} not found\n`;
+    } else if (showAll) {
+      for (const f of found) out += f + "\n";
+    } else {
+      out += found[0] + "\n";
+    }
+  }
+  return out.includes("not found")
+    ? { stdout: out, stderr: "", exitCode: 1 }
+    : ok(out);
+};
+
+const typeCmd: BuiltinFn = (args, ctx) => {
+  if (args.length === 0) return fail("type: missing argument\n");
+  const name = args[0];
+  if (_builtins?.has(name)) return ok(`${name} is a shell builtin\n`);
+
+  const w = which([name], ctx);
+  if (typeof w === "object" && "exitCode" in w && w.exitCode === 0) {
+    return ok(`${name} is ${w.stdout.trim()}\n`);
+  }
+  return fail(`type: ${name}: not found\n`);
+};
+
+const trueCmd: BuiltinFn = () => ok();
+const falseCmd: BuiltinFn = () => EXIT_FAIL;
+
+const exitCmd: BuiltinFn = (args) => {
+  const code = args[0] ? parseInt(args[0], 10) : 0;
+  return { stdout: "", stderr: "", exitCode: code };
+};
+
+const clear: BuiltinFn = () => ok("\x1b[2J\x1b[H");
+
+/* ------------------------------------------------------------------ */
+/*  test / [                                                           */
+/* ------------------------------------------------------------------ */
+
+function evalTest(args: string[], ctx: ShellContext): boolean {
+  if (args.length === 0) return false;
+
+  if (args[0] === "!") return !evalTest(args.slice(1), ctx);
+
+  if (args[0] === "(" && args[args.length - 1] === ")") {
+    return evalTest(args.slice(1, -1), ctx);
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-o") {
+      return (
+        evalTest(args.slice(0, i), ctx) || evalTest(args.slice(i + 1), ctx)
+      );
+    }
+  }
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-a") {
+      return (
+        evalTest(args.slice(0, i), ctx) && evalTest(args.slice(i + 1), ctx)
+      );
+    }
+  }
+
+  if (args.length === 1) return args[0].length > 0;
+
+  if (args.length === 2) {
+    const [flag, val] = args;
+    const p = resolvePath(val, ctx.cwd);
+
+    if (flag === "-f") {
+      try { return ctx.volume.statSync(p).isFile(); } catch { return false; }
+    }
+    if (flag === "-d") {
+      try { return ctx.volume.statSync(p).isDirectory(); } catch { return false; }
+    }
+    if (flag === "-e") return ctx.volume.existsSync(p);
+    if (flag === "-L" || flag === "-h") return ctx.volume.existsSync(p);
+    if (flag === "-s") {
+      try { return ctx.volume.readFileSync(p).length > 0; } catch { return false; }
+    }
+    if (flag === "-r" || flag === "-w") return ctx.volume.existsSync(p);
+    if (flag === "-x") {
+      if (ctx.volume.existsSync(p)) {
+        const ext = pathModule.extname(p);
+        return ext === ".sh" || ext === "" || p.includes("/bin/");
+      }
+      return false;
+    }
+    if (flag === "-n") return val.length > 0;
+    if (flag === "-z") return val.length === 0;
+    if (flag === "-t") return false;
+  }
+
+  if (args.length === 3) {
+    const [left, op, right] = args;
+    if (op === "=" || op === "==") return left === right;
+    if (op === "!=") return left !== right;
+    if (op === "-eq") return parseInt(left) === parseInt(right);
+    if (op === "-ne") return parseInt(left) !== parseInt(right);
+    if (op === "-lt") return parseInt(left) < parseInt(right);
+    if (op === "-le") return parseInt(left) <= parseInt(right);
+    if (op === "-gt") return parseInt(left) > parseInt(right);
+    if (op === "-ge") return parseInt(left) >= parseInt(right);
+
+    if (op === "-nt" || op === "-ot" || op === "-ef") {
+      try {
+        const sl = ctx.volume.statSync(resolvePath(left, ctx.cwd));
+        const sr = ctx.volume.statSync(resolvePath(right, ctx.cwd));
+        if (op === "-nt") return (sl.mtimeMs || 0) > (sr.mtimeMs || 0);
+        if (op === "-ot") return (sl.mtimeMs || 0) < (sr.mtimeMs || 0);
+        if (op === "-ef")
+          return resolvePath(left, ctx.cwd) === resolvePath(right, ctx.cwd);
+      } catch {
+        return false;
+      }
+    }
+  }
+
+  return false;
+}
+
+const test_cmd: BuiltinFn = (args, ctx) => {
+  const testArgs = [...args];
+  if (testArgs[testArgs.length - 1] === "]") testArgs.pop();
+  return { stdout: "", stderr: "", exitCode: evalTest(testArgs, ctx) ? 0 : 1 };
+};
+
+/* ------------------------------------------------------------------ */
+/*  date                                                               */
+/* ------------------------------------------------------------------ */
+
+function getTimezoneAbbr(d: Date): string {
+  const str = d.toTimeString();
+  const m = str.match(/\((.+?)\)/);
+  if (m) {
+    const words = m[1].split(" ");
+    if (words.length === 1) return words[0];
+    return words.map((w) => w[0]).join("");
+  }
+  const off = -d.getTimezoneOffset();
+  const sign = off >= 0 ? "+" : "-";
+  const h = String(Math.floor(Math.abs(off) / 60)).padStart(2, "0");
+  const min = String(Math.abs(off) % 60).padStart(2, "0");
+  return `${sign}${h}${min}`;
+}
+
+function formatDate(d: Date, fmt: string, utc: boolean): string {
+  const g = utc
+    ? {
+        Y: d.getUTCFullYear(), m: d.getUTCMonth(), d: d.getUTCDate(),
+        H: d.getUTCHours(), M: d.getUTCMinutes(), S: d.getUTCSeconds(),
+        w: d.getUTCDay(),
+      }
+    : {
+        Y: d.getFullYear(), m: d.getMonth(), d: d.getDate(),
+        H: d.getHours(), M: d.getMinutes(), S: d.getSeconds(),
+        w: d.getDay(),
+      };
+  let out = "";
+  for (let i = 0; i < fmt.length; i++) {
+    if (fmt[i] === "%" && i + 1 < fmt.length) {
+      const s = fmt[++i];
+      if (s === "Y") out += g.Y;
+      else if (s === "y") out += String(g.Y).slice(-2);
+      else if (s === "m") out += String(g.m + 1).padStart(2, "0");
+      else if (s === "d") out += String(g.d).padStart(2, "0");
+      else if (s === "e") out += String(g.d).padStart(2, " ");
+      else if (s === "H") out += String(g.H).padStart(2, "0");
+      else if (s === "M") out += String(g.M).padStart(2, "0");
+      else if (s === "S") out += String(g.S).padStart(2, "0");
+      else if (s === "I") out += String(g.H % 12 || 12).padStart(2, "0");
+      else if (s === "p") out += g.H < 12 ? "AM" : "PM";
+      else if (s === "P") out += g.H < 12 ? "am" : "pm";
+      else if (s === "a") out += DAYS_SHORT[g.w];
+      else if (s === "A") out += DAYS_LONG[g.w];
+      else if (s === "b" || s === "h") out += MONTHS_SHORT[g.m];
+      else if (s === "B") out += MONTHS_LONG[g.m];
+      else if (s === "w") out += g.w;
+      else if (s === "u") out += g.w === 0 ? 7 : g.w;
+      else if (s === "j") {
+        const jan1 = new Date(g.Y, 0, 1);
+        const diff = d.getTime() - jan1.getTime();
+        out += String(Math.floor(diff / 86400000) + 1).padStart(3, "0");
+      } else if (s === "s") out += Math.floor(d.getTime() / 1000);
+      else if (s === "N") out += String(d.getMilliseconds() * 1000000).padStart(9, "0");
+      else if (s === "n") out += "\n";
+      else if (s === "t") out += "\t";
+      else if (s === "T")
+        out += `${String(g.H).padStart(2, "0")}:${String(g.M).padStart(2, "0")}:${String(g.S).padStart(2, "0")}`;
+      else if (s === "R")
+        out += `${String(g.H).padStart(2, "0")}:${String(g.M).padStart(2, "0")}`;
+      else if (s === "F")
+        out += `${g.Y}-${String(g.m + 1).padStart(2, "0")}-${String(g.d).padStart(2, "0")}`;
+      else if (s === "D")
+        out += `${String(g.m + 1).padStart(2, "0")}/${String(g.d).padStart(2, "0")}/${String(g.Y).slice(-2)}`;
+      else if (s === "Z") out += utc ? "UTC" : getTimezoneAbbr(d);
+      else if (s === "%") out += "%";
+      else out += "%" + s;
+    } else {
+      out += fmt[i];
+    }
+  }
+  return out;
+}
+
+const date_cmd: BuiltinFn = (args) => {
+  const { flags, opts, positional } = parseArgs(args, ["u", "R", "I"], ["d"]);
+  const utc = flags.has("u");
+  const rfc = flags.has("R");
+  const iso = flags.has("I");
+  const dateStr = opts["d"];
+
+  const d = dateStr ? new Date(dateStr) : new Date();
+  if (isNaN(d.getTime())) return fail(`date: invalid date '${dateStr}'\n`);
+
+  const fmt = positional.find((a) => a.startsWith("+"));
+  if (fmt) return ok(formatDate(d, fmt.slice(1), utc) + "\n");
+  if (rfc) return ok(d.toUTCString() + "\n");
+  if (iso) return ok(d.toISOString().slice(0, 10) + "\n");
+
+  const day = DAYS_SHORT[utc ? d.getUTCDay() : d.getDay()];
+  const mon = MONTHS_SHORT[utc ? d.getUTCMonth() : d.getMonth()];
+  const date = utc ? d.getUTCDate() : d.getDate();
+  const hh = String(utc ? d.getUTCHours() : d.getHours()).padStart(2, "0");
+  const mm = String(utc ? d.getUTCMinutes() : d.getMinutes()).padStart(2, "0");
+  const ss = String(utc ? d.getUTCSeconds() : d.getSeconds()).padStart(2, "0");
+  const year = utc ? d.getUTCFullYear() : d.getFullYear();
+  const tz = utc ? "UTC" : getTimezoneAbbr(d);
+
+  return ok(
+    `${day} ${mon} ${String(date).padStart(2, " ")} ${hh}:${mm}:${ss} ${tz} ${year}\n`,
+  );
+};
+
+/* ------------------------------------------------------------------ */
+/*  sleep                                                              */
+/* ------------------------------------------------------------------ */
+
+const sleep_cmd: BuiltinFn = async (args) => {
+  const seconds = parseFloat(args[0] || "0");
+  if (seconds > 0) await new Promise((r) => setTimeout(r, seconds * 1000));
+  return ok();
+};
+
+/* ------------------------------------------------------------------ */
+/*  Registry                                                           */
+/* ------------------------------------------------------------------ */
+
+export const shellEnvCommands: [string, BuiltinFn][] = [
+  ["export", exportCmd],
+  ["unset", unset],
+  ["env", envCmd],
+  ["which", which],
+  ["type", typeCmd],
+  ["true", trueCmd],
+  ["false", falseCmd],
+  [":", trueCmd],
+  ["exit", exitCmd],
+  ["clear", clear],
+  ["test", test_cmd],
+  ["[", test_cmd],
+  ["date", date_cmd],
+  ["sleep", sleep_cmd],
+];