@scelar/nodepod 1.0.0

package/src/shell/commands/file-ops.ts

@@ -0,0 +1,525 @@
+import type { BuiltinFn, ShellContext } from "../shell-types";
+import {
+  ok,
+  fail,
+  resolvePath,
+  parseArgs,
+  pathModule,
+} from "../shell-helpers";
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+function formatCat(
+  content: string,
+  numberAll: boolean,
+  numberNonBlank: boolean,
+  squeeze: boolean,
+  showEnds: boolean,
+  showTabs: boolean,
+): string {
+  let lines = content.split("\n");
+  if (squeeze) {
+    const squeezed: string[] = [];
+    let prevBlank = false;
+    for (const line of lines) {
+      const blank = line.length === 0;
+      if (blank && prevBlank) continue;
+      squeezed.push(line);
+      prevBlank = blank;
+    }
+    lines = squeezed;
+  }
+  let lineNum = 1;
+  const result = lines.map((line, idx) => {
+    let l = line;
+    if (showTabs) l = l.replace(/\t/g, "^I");
+    if (showEnds && idx < lines.length - 1) l += "$";
+    if (numberNonBlank) {
+      if (line.length > 0) l = `${String(lineNum++).padStart(6)}\t${l}`;
+    } else if (numberAll) {
+      l = `${String(lineNum++).padStart(6)}\t${l}`;
+    }
+    return l;
+  });
+  return result.join("\n");
+}
+
+function copyTree(ctx: ShellContext, src: string, dst: string): void {
+  ctx.volume.mkdirSync(dst, { recursive: true });
+  for (const name of ctx.volume.readdirSync(src)) {
+    const s = `${src}/${name}`;
+    const d = `${dst}/${name}`;
+    const st = ctx.volume.statSync(s);
+    if (st.isDirectory()) {
+      copyTree(ctx, s, d);
+    } else {
+      ctx.volume.writeFileSync(d, ctx.volume.readFileSync(s));
+    }
+  }
+}
+
+function removeTree(ctx: ShellContext, dir: string): void {
+  for (const name of ctx.volume.readdirSync(dir)) {
+    const full = `${dir}/${name}`;
+    const st = ctx.volume.statSync(full);
+    if (st.isDirectory()) removeTree(ctx, full);
+    else ctx.volume.unlinkSync(full);
+  }
+  ctx.volume.rmdirSync(dir);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Commands                                                           */
+/* ------------------------------------------------------------------ */
+
+const cat: BuiltinFn = (args, ctx, stdin) => {
+  const { flags, positional } = parseArgs(args, [
+    "n",
+    "b",
+    "s",
+    "E",
+    "T",
+    "A",
+    "e",
+    "t",
+    "v",
+  ]);
+  const numberAll = flags.has("n") || flags.has("A");
+  const numberNonBlank = flags.has("b");
+  const squeeze = flags.has("s");
+  const showEnds = flags.has("E") || flags.has("A") || flags.has("e");
+  const showTabs = flags.has("T") || flags.has("A") || flags.has("t");
+
+  if (positional.length === 0 && stdin !== undefined) {
+    return ok(
+      formatCat(stdin, numberAll, numberNonBlank, squeeze, showEnds, showTabs),
+    );
+  }
+  if (positional.length === 0) return fail("cat: missing operand\n");
+
+  let out = "";
+  for (const file of positional) {
+    if (file === "-" && stdin !== undefined) {
+      out += formatCat(
+        stdin,
+        numberAll,
+        numberNonBlank,
+        squeeze,
+        showEnds,
+        showTabs,
+      );
+      continue;
+    }
+    const p = resolvePath(file, ctx.cwd);
+    try {
+      const content = ctx.volume.readFileSync(p, "utf8");
+      out += formatCat(
+        content,
+        numberAll,
+        numberNonBlank,
+        squeeze,
+        showEnds,
+        showTabs,
+      );
+    } catch {
+      return fail(`cat: ${file}: No such file or directory\n`);
+    }
+  }
+  return ok(out);
+};
+
+const head: BuiltinFn = (args, ctx, stdin) => {
+  let n = 10;
+  let byteMode = false;
+  let bytes = 0;
+  const files: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-n" && i + 1 < args.length) {
+      n = parseInt(args[++i], 10) || 10;
+    } else if (args[i] === "-c" && i + 1 < args.length) {
+      bytes = parseInt(args[++i], 10) || 0;
+      byteMode = true;
+    } else if (args[i].startsWith("-") && /^\d+$/.test(args[i].slice(1))) {
+      n = parseInt(args[i].slice(1), 10);
+    } else if (!args[i].startsWith("-")) {
+      files.push(args[i]);
+    }
+  }
+
+  const doHead = (content: string) => {
+    if (byteMode) return content.slice(0, bytes);
+    return content.split("\n").slice(0, n).join("\n") + "\n";
+  };
+
+  if (files.length === 0 && stdin !== undefined) return ok(doHead(stdin));
+  if (files.length === 0) return fail("head: missing operand\n");
+
+  let out = "";
+  for (const file of files) {
+    const p = resolvePath(file, ctx.cwd);
+    try {
+      const content = ctx.volume.readFileSync(p, "utf8");
+      if (files.length > 1) out += `==> ${file} <==\n`;
+      out += doHead(content);
+    } catch {
+      return fail(`head: ${file}: No such file or directory\n`);
+    }
+  }
+  return ok(out);
+};
+
+const tail: BuiltinFn = (args, ctx, stdin) => {
+  let n = 10;
+  let byteMode = false;
+  let bytes = 0;
+  const files: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-n" && i + 1 < args.length) {
+      n = parseInt(args[++i], 10) || 10;
+    } else if (args[i] === "-c" && i + 1 < args.length) {
+      bytes = parseInt(args[++i], 10) || 0;
+      byteMode = true;
+    } else if (args[i] === "-f") {
+      // -f (follow) can't work in VFS, ignore
+    } else if (args[i].startsWith("-") && /^\d+$/.test(args[i].slice(1))) {
+      n = parseInt(args[i].slice(1), 10);
+    } else if (!args[i].startsWith("-")) {
+      files.push(args[i]);
+    }
+  }
+
+  const doTail = (content: string) => {
+    if (byteMode) return content.slice(-bytes);
+    const lines = content.split("\n");
+    const start = Math.max(
+      0,
+      lines.length - n - (content.endsWith("\n") ? 1 : 0),
+    );
+    return lines.slice(start).join("\n");
+  };
+
+  if (files.length === 0 && stdin !== undefined) return ok(doTail(stdin));
+  if (files.length === 0) return fail("tail: missing operand\n");
+
+  let out = "";
+  for (const file of files) {
+    const p = resolvePath(file, ctx.cwd);
+    try {
+      const content = ctx.volume.readFileSync(p, "utf8");
+      if (files.length > 1) out += `==> ${file} <==\n`;
+      out += doTail(content);
+    } catch {
+      return fail(`tail: ${file}: No such file or directory\n`);
+    }
+  }
+  return ok(out);
+};
+
+const touch: BuiltinFn = (args, ctx) => {
+  if (args.length === 0) return fail("touch: missing operand\n");
+  for (const file of args) {
+    if (file.startsWith("-")) continue;
+    const p = resolvePath(file, ctx.cwd);
+    if (!ctx.volume.existsSync(p)) {
+      ctx.volume.writeFileSync(p, "");
+    }
+  }
+  return ok();
+};
+
+const cpCmd: BuiltinFn = (args, ctx) => {
+  const { flags, positional } = parseArgs(args, ["r", "R", "f", "n", "v"]);
+  const recursive = flags.has("r") || flags.has("R") || flags.has("recursive");
+  const verbose = flags.has("v");
+
+  if (positional.length < 2) return fail("cp: missing operand\n");
+
+  const dest = positional[positional.length - 1];
+  const sources = positional.slice(0, -1);
+  const dstPath = resolvePath(dest, ctx.cwd);
+  let out = "";
+
+  for (const src of sources) {
+    const srcPath = resolvePath(src, ctx.cwd);
+    try {
+      const st = ctx.volume.statSync(srcPath);
+      if (st.isDirectory()) {
+        if (!recursive)
+          return fail(`cp: -r not specified; omitting directory '${src}'\n`);
+        copyTree(ctx, srcPath, dstPath);
+        if (verbose) out += `'${src}' -> '${dest}'\n`;
+      } else {
+        let destFinal = dstPath;
+        if (ctx.volume.existsSync(dstPath)) {
+          try {
+            if (ctx.volume.statSync(dstPath).isDirectory()) {
+              destFinal = `${dstPath}/${pathModule.basename(srcPath)}`;
+            }
+          } catch {
+            /* */
+          }
+        }
+        ctx.volume.writeFileSync(destFinal, ctx.volume.readFileSync(srcPath));
+        if (verbose) out += `'${src}' -> '${dest}'\n`;
+      }
+    } catch {
+      return fail(`cp: cannot stat '${src}': No such file or directory\n`);
+    }
+  }
+  return ok(out);
+};
+
+const mv: BuiltinFn = (args, ctx) => {
+  const { flags, positional } = parseArgs(args, ["f", "n", "v"]);
+  const verbose = flags.has("v");
+  if (positional.length < 2) return fail("mv: missing operand\n");
+
+  const dest = positional[positional.length - 1];
+  const sources = positional.slice(0, -1);
+  const dstPath = resolvePath(dest, ctx.cwd);
+  let out = "";
+
+  for (const src of sources) {
+    const srcPath = resolvePath(src, ctx.cwd);
+    try {
+      let destFinal = dstPath;
+      if (ctx.volume.existsSync(dstPath)) {
+        try {
+          if (ctx.volume.statSync(dstPath).isDirectory()) {
+            destFinal = `${dstPath}/${pathModule.basename(srcPath)}`;
+          }
+        } catch {
+          /* */
+        }
+      }
+      ctx.volume.renameSync(srcPath, destFinal);
+      if (verbose) out += `renamed '${src}' -> '${dest}'\n`;
+    } catch {
+      return fail(
+        `mv: cannot move '${src}' to '${dest}': No such file or directory\n`,
+      );
+    }
+  }
+  return ok(out);
+};
+
+const rm: BuiltinFn = (args, ctx) => {
+  const { flags, positional } = parseArgs(args, ["r", "R", "f", "v"]);
+  const recursive = flags.has("r") || flags.has("R") || flags.has("recursive");
+  const force = flags.has("f") || flags.has("force");
+  const verbose = flags.has("v");
+
+  if (positional.length === 0 && !force) return fail("rm: missing operand\n");
+
+  let out = "";
+  for (const target of positional) {
+    const p = resolvePath(target, ctx.cwd);
+    if (!ctx.volume.existsSync(p)) {
+      if (force) continue;
+      return fail(`rm: cannot remove '${target}': No such file or directory\n`);
+    }
+    const st = ctx.volume.statSync(p);
+    if (st.isDirectory()) {
+      if (!recursive)
+        return fail(`rm: cannot remove '${target}': Is a directory\n`);
+      removeTree(ctx, p);
+      if (verbose) out += `removed directory '${target}'\n`;
+    } else {
+      ctx.volume.unlinkSync(p);
+      if (verbose) out += `removed '${target}'\n`;
+    }
+  }
+  return ok(out);
+};
+
+const mkdir_cmd: BuiltinFn = (args, ctx) => {
+  const { flags, positional } = parseArgs(args, ["p", "v"]);
+  const recursive = flags.has("p");
+  const verbose = flags.has("v");
+
+  if (positional.length === 0) return fail("mkdir: missing operand\n");
+
+  let out = "";
+  for (const dir of positional) {
+    const p = resolvePath(dir, ctx.cwd);
+    try {
+      ctx.volume.mkdirSync(p, { recursive });
+      if (verbose) out += `mkdir: created directory '${dir}'\n`;
+    } catch (e) {
+      if (!recursive)
+        return fail(
+          `mkdir: cannot create directory '${dir}': ${e instanceof Error ? e.message : String(e)}\n`,
+        );
+    }
+  }
+  return ok(out);
+};
+
+const rmdir_cmd: BuiltinFn = (args, ctx) => {
+  const { flags, positional } = parseArgs(args, ["p", "v"]);
+  const parents = flags.has("p");
+  const verbose = flags.has("v");
+
+  if (positional.length === 0) return fail("rmdir: missing operand\n");
+
+  let out = "";
+  for (const dir of positional) {
+    let p = resolvePath(dir, ctx.cwd);
+    try {
+      ctx.volume.rmdirSync(p);
+      if (verbose) out += `rmdir: removing directory, '${dir}'\n`;
+      if (parents) {
+        while (p !== "/") {
+          p = pathModule.dirname(p);
+          if (p === "/") break;
+          try {
+            ctx.volume.rmdirSync(p);
+          } catch {
+            break;
+          }
+        }
+      }
+    } catch {
+      return fail(
+        `rmdir: failed to remove '${dir}': Directory not empty or not found\n`,
+      );
+    }
+  }
+  return ok(out);
+};
+
+const chmod: BuiltinFn = (args, _ctx) => {
+  if (args.length < 2) return fail("chmod: missing operand\n");
+  return ok(); // no-op in VFS
+};
+
+const wc: BuiltinFn = (args, ctx, stdin) => {
+  const { flags, positional } = parseArgs(args, ["l", "w", "c", "m", "L"]);
+  const showLines = flags.has("l");
+  const showWords = flags.has("w");
+  const showBytes = flags.has("c");
+  const showChars = flags.has("m");
+  const showMaxLine = flags.has("L");
+  const showAll =
+    !showLines && !showWords && !showBytes && !showChars && !showMaxLine;
+
+  const doWc = (content: string, label?: string) => {
+    const lines = content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+    const words = content.split(/\s+/).filter(Boolean).length;
+    const bytes = new TextEncoder().encode(content).length;
+    const chars = [...content].length;
+    const maxLine = content
+      .split("\n")
+      .reduce((mx, l) => Math.max(mx, l.length), 0);
+
+    const parts: string[] = [];
+    if (showAll || showLines) parts.push(String(lines).padStart(7));
+    if (showAll || showWords) parts.push(String(words).padStart(7));
+    if (showChars) parts.push(String(chars).padStart(7));
+    if (showAll || showBytes) parts.push(String(bytes).padStart(7));
+    if (showMaxLine) parts.push(String(maxLine).padStart(7));
+
+    const suffix = label ? ` ${label}` : "";
+    return parts.join("") + suffix + "\n";
+  };
+
+  if (positional.length === 0 && stdin !== undefined) return ok(doWc(stdin));
+  if (positional.length === 0) return fail("wc: missing operand\n");
+
+  let out = "";
+  let totalLines = 0,
+    totalWords = 0,
+    totalBytes = 0;
+  for (const file of positional) {
+    const p = resolvePath(file, ctx.cwd);
+    try {
+      const content = ctx.volume.readFileSync(p, "utf8");
+      out += doWc(content, file);
+      totalLines +=
+        content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+      totalWords += content.split(/\s+/).filter(Boolean).length;
+      totalBytes += new TextEncoder().encode(content).length;
+    } catch {
+      return fail(`wc: ${file}: No such file or directory\n`);
+    }
+  }
+  if (positional.length > 1) {
+    const parts: string[] = [];
+    if (showAll || showLines) parts.push(String(totalLines).padStart(7));
+    if (showAll || showWords) parts.push(String(totalWords).padStart(7));
+    if (showAll || showBytes) parts.push(String(totalBytes).padStart(7));
+    out += parts.join("") + " total\n";
+  }
+  return ok(out);
+};
+
+const tee: BuiltinFn = (args, ctx, stdin) => {
+  const { flags, positional } = parseArgs(args, ["a"]);
+  const append = flags.has("a");
+  const content = stdin ?? "";
+
+  for (const file of positional) {
+    const p = resolvePath(file, ctx.cwd);
+    if (append && ctx.volume.existsSync(p)) {
+      const existing = ctx.volume.readFileSync(p, "utf8");
+      ctx.volume.writeFileSync(p, existing + content);
+    } else {
+      ctx.volume.writeFileSync(p, content);
+    }
+  }
+  return ok(content);
+};
+
+const readlink_cmd: BuiltinFn = (args, ctx) => {
+  const { positional } = parseArgs(args, ["f", "e", "m", "n", "q", "z"]);
+  if (positional.length === 0) return fail("readlink: missing operand\n");
+  const p = resolvePath(positional[0], ctx.cwd);
+  return ok(p + "\n");
+};
+
+const ln_cmd: BuiltinFn = (args, ctx) => {
+  const { positional } = parseArgs(args, ["s", "f"]);
+  if (positional.length < 2) return fail("ln: missing operand\n");
+  const src = resolvePath(positional[0], ctx.cwd);
+  const dst = resolvePath(positional[1], ctx.cwd);
+  try {
+    const content = ctx.volume.readFileSync(src);
+    ctx.volume.writeFileSync(dst, content);
+    return ok();
+  } catch {
+    return fail(
+      `ln: cannot create link '${positional[1]}': source not found\n`,
+    );
+  }
+};
+
+const writeFile: BuiltinFn = (args, ctx) => {
+  if (args.length < 2) return fail("write: missing arguments\n");
+  const path = resolvePath(args[0], ctx.cwd);
+  ctx.volume.writeFileSync(path, args.slice(1).join(" "));
+  return ok();
+};
+
+/* ------------------------------------------------------------------ */
+/*  Registry                                                           */
+/* ------------------------------------------------------------------ */
+
+export const fileOpsCommands: [string, BuiltinFn][] = [
+  ["cat", cat],
+  ["head", head],
+  ["tail", tail],
+  ["touch", touch],
+  ["cp", cpCmd],
+  ["mv", mv],
+  ["rm", rm],
+  ["mkdir", mkdir_cmd],
+  ["rmdir", rmdir_cmd],
+  ["chmod", chmod],
+  ["wc", wc],
+  ["tee", tee],
+  ["ln", ln_cmd],
+  ["readlink", readlink_cmd],
+  ["write", writeFile],
+];