@scelar/nodepod 1.0.0

package/src/shell/commands/node.ts

@@ -0,0 +1,80 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+import { VERSIONS } from "../../constants/config";
+
+const A_RESET = "\x1b[0m";
+const A_BOLD = "\x1b[1m";
+
+export function createNodeCommand(deps: PmDeps): ShellCommand {
+  return {
+    name: "node",
+    async execute(params, ctx) {
+      if (!deps.hasFile("/"))
+        return { stdout: "", stderr: "Volume unavailable\n", exitCode: 1 };
+
+      let target: string | null = null;
+      let evalCode: string | null = null;
+      let printCode: string | null = null;
+      const scriptArgs: string[] = [];
+      let collectingArgs = false;
+
+      for (let i = 0; i < params.length; i++) {
+        if (collectingArgs) {
+          scriptArgs.push(params[i]);
+          continue;
+        }
+        if (params[i] === "-e" || params[i] === "--eval") {
+          evalCode = params[++i] ?? "";
+        } else if (params[i] === "-p" || params[i] === "--print") {
+          printCode = params[++i] ?? "";
+        } else if (params[i] === "--version" || params[i] === "-v") {
+          return { stdout: VERSIONS.NODE + "\n", stderr: "", exitCode: 0 };
+        } else if (params[i] === "--help" || params[i] === "-h") {
+          return {
+            stdout: `${A_BOLD}Usage:${A_RESET} node [options] [script.js] [arguments]\n`,
+            stderr: "",
+            exitCode: 0,
+          };
+        } else if (
+          params[i] === "-r" ||
+          params[i] === "--require" ||
+          params[i] === "--experimental-specifier-resolution" ||
+          params[i] === "--loader" ||
+          params[i] === "--import"
+        ) {
+          i++;
+        } else if (params[i].startsWith("-")) {
+          // skip unknown flags (--harmony, --inspect, etc.)
+        } else {
+          target = params[i];
+          collectingArgs = true;
+        }
+      }
+
+      if (evalCode !== null) {
+        return deps.evalCode(evalCode, ctx);
+      }
+      if (printCode !== null) {
+        return deps.printCode(printCode, ctx);
+      }
+
+      if (!target)
+        return {
+          stdout: "",
+          stderr: `${A_BOLD}Usage:${A_RESET} node <file> [args...]\n`,
+          exitCode: 1,
+        };
+
+      return deps.executeNodeBinary(target, scriptArgs, ctx);
+    },
+  };
+}
+
+export function createNpxCommand(deps: PmDeps): ShellCommand {
+  return {
+    name: "npx",
+    async execute(params, ctx) {
+      return deps.npxExecute(params, ctx);
+    },
+  };
+}

package/src/shell/commands/npm.ts

@@ -0,0 +1,198 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+import { VERSIONS, NPM_REGISTRY_URL_SLASH } from "../../constants/config";
+
+const A_RESET = "\x1b[0m";
+const A_BOLD = "\x1b[1m";
+const A_CYAN = "\x1b[36m";
+
+export function createNpmCommand(deps: PmDeps): ShellCommand {
+  return {
+    name: "npm",
+    async execute(params, ctx) {
+      if (!deps.hasFile("/"))
+        return { stdout: "", stderr: "Volume unavailable\n", exitCode: 1 };
+
+      const sub = params[0];
+      if (!sub || sub === "help" || sub === "--help") {
+        return {
+          stdout:
+            `${A_BOLD}Usage:${A_RESET} npm <command>\n\n` +
+            `${A_BOLD}Commands:${A_RESET}\n` +
+            `  ${A_CYAN}run${A_RESET} <script>      Run a package.json script\n` +
+            `  ${A_CYAN}start${A_RESET}             Alias for npm run start\n` +
+            `  ${A_CYAN}test${A_RESET}              Alias for npm run test\n` +
+            `  ${A_CYAN}install${A_RESET} [pkg]     Install packages\n` +
+            `  ${A_CYAN}uninstall${A_RESET} <pkg>   Remove a package\n` +
+            `  ${A_CYAN}ls${A_RESET}                List installed packages\n` +
+            `  ${A_CYAN}init${A_RESET}              Create a package.json\n` +
+            `  ${A_CYAN}create${A_RESET} <pkg>      Create a project (runs create-<pkg>)\n` +
+            `  ${A_CYAN}version${A_RESET}           Show version info\n` +
+            `  ${A_CYAN}info${A_RESET} <pkg>        Show package info\n` +
+            `  ${A_CYAN}exec${A_RESET} <cmd>        Execute a package binary\n` +
+            `  ${A_CYAN}prefix${A_RESET}            Show prefix\n` +
+            `  ${A_CYAN}root${A_RESET}              Show node_modules path\n` +
+            `  ${A_CYAN}bin${A_RESET}               Show bin directory\n` +
+            `  ${A_CYAN}config${A_RESET}            Manage configuration\n`,
+          stderr: "",
+          exitCode: 0,
+        };
+      }
+
+      switch (sub) {
+        case "run":
+        case "run-script":
+          return deps.runScript(params.slice(1), ctx);
+        case "start":
+          return deps.runScript(["start"], ctx);
+        case "test":
+        case "t":
+        case "tst":
+          return deps.runScript(["test"], ctx);
+        case "install":
+        case "i":
+        case "add":
+          return deps.installPackages(params.slice(1), ctx);
+        case "ci":
+          try {
+            deps.removeNodeModules(ctx.cwd);
+          } catch {
+            /* */
+          }
+          return deps.installPackages([], ctx);
+        case "uninstall":
+        case "remove":
+        case "rm":
+        case "un":
+          return deps.uninstallPackages(params.slice(1), ctx);
+        case "ls":
+        case "list":
+          return deps.listPackages(ctx);
+        case "init":
+        case "create":
+          return deps.npmInitOrCreate(params.slice(1), sub, ctx);
+        case "version":
+        case "-v":
+        case "--version":
+          return { stdout: VERSIONS.NPM + "\n", stderr: "", exitCode: 0 };
+        case "info":
+        case "view":
+        case "show":
+          return deps.npmInfo(params.slice(1), ctx);
+        case "exec":
+          return deps.npxExecute(params.slice(1), ctx);
+        case "prefix":
+          return { stdout: ctx.cwd + "\n", stderr: "", exitCode: 0 };
+        case "root":
+          return {
+            stdout: ctx.cwd + "/node_modules\n",
+            stderr: "",
+            exitCode: 0,
+          };
+        case "bin":
+          return {
+            stdout: ctx.cwd + "/node_modules/.bin\n",
+            stderr: "",
+            exitCode: 0,
+          };
+        case "pack":
+          return deps.npmPack(ctx);
+        case "config":
+        case "c":
+          return deps.npmConfig(params.slice(1), ctx);
+        case "outdated":
+          return {
+            stdout: "",
+            stderr: deps.formatWarn(
+              "outdated check not available in nodepod",
+              "npm",
+            ),
+            exitCode: 0,
+          };
+        case "audit":
+          return {
+            stdout: "found 0 vulnerabilities\n",
+            stderr: "",
+            exitCode: 0,
+          };
+        case "fund":
+          return {
+            stdout: "0 packages are looking for funding\n",
+            stderr: "",
+            exitCode: 0,
+          };
+        case "cache":
+          if (params[1] === "clean" || params[1] === "clear") {
+            return { stdout: "Cache cleared.\n", stderr: "", exitCode: 0 };
+          }
+          return {
+            stdout: "",
+            stderr: deps.formatErr(
+              `cache: unknown subcommand ${params[1] ?? ""}`,
+              "npm",
+            ),
+            exitCode: 1,
+          };
+        case "whoami":
+          return { stdout: "nodepod-user\n", stderr: "", exitCode: 0 };
+        case "ping":
+          return {
+            stdout: `PING ${NPM_REGISTRY_URL_SLASH} - ok\n`,
+            stderr: "",
+            exitCode: 0,
+          };
+        case "set-script": {
+          const scriptName = params[1];
+          const scriptCmd = params.slice(2).join(" ");
+          if (!scriptName || !scriptCmd) {
+            return {
+              stdout: "",
+              stderr: deps.formatErr(
+                "Usage: npm set-script <name> <command>",
+                "npm",
+              ),
+              exitCode: 1,
+            };
+          }
+          try {
+            const pkgPath = ctx.cwd + "/package.json";
+            const raw = deps.readFile(pkgPath);
+            const pkg = JSON.parse(raw);
+            if (!pkg.scripts) pkg.scripts = {};
+            pkg.scripts[scriptName] = scriptCmd;
+            deps.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+            return {
+              stdout: "",
+              stderr: deps.formatWarn(
+                "`set-script` is deprecated. Use `npm pkg set scripts.${scriptName}=\"${scriptCmd}\"` instead.",
+                "npm",
+              ),
+              exitCode: 0,
+            };
+          } catch (e: any) {
+            return {
+              stdout: "",
+              stderr: deps.formatErr(
+                e.message || "Failed to update package.json",
+                "npm",
+              ),
+              exitCode: 1,
+            };
+          }
+        }
+        case "pkg":
+          return deps.npmPkg ? deps.npmPkg(params.slice(1), ctx) : {
+            stdout: "",
+            stderr: deps.formatErr("npm pkg not implemented", "npm"),
+            exitCode: 1,
+          };
+        default:
+          return {
+            stdout: "",
+            stderr: deps.formatErr(`Unknown command "${sub}"`, "npm"),
+            exitCode: 1,
+          };
+      }
+    },
+  };
+}

package/src/shell/commands/pm-types.ts

@@ -0,0 +1,45 @@
+// Shared types for package manager commands (npm, pnpm, yarn, bun).
+// Each PM file is a factory that receives these deps from child_process.ts.
+
+import type { ShellCommand, ShellResult, ShellContext } from "../shell-types";
+
+export type PkgManager = "npm" | "pnpm" | "yarn" | "bun";
+
+export interface PmDeps {
+  installPackages: (
+    args: string[],
+    ctx: ShellContext,
+    pm?: PkgManager,
+  ) => Promise<ShellResult>;
+  uninstallPackages: (
+    args: string[],
+    ctx: ShellContext,
+    pm?: PkgManager,
+  ) => Promise<ShellResult>;
+  listPackages: (ctx: ShellContext, pm?: PkgManager) => Promise<ShellResult>;
+  runScript: (args: string[], ctx: ShellContext) => Promise<ShellResult>;
+  npmInitOrCreate: (
+    args: string[],
+    sub: string,
+    ctx: ShellContext,
+  ) => Promise<ShellResult>;
+  npmInfo: (args: string[], ctx: ShellContext) => Promise<ShellResult>;
+  npmPack: (ctx: ShellContext) => ShellResult;
+  npmConfig: (args: string[], ctx: ShellContext) => ShellResult;
+  npxExecute: (params: string[], ctx: ShellContext) => Promise<ShellResult>;
+  executeNodeBinary: (
+    filePath: string,
+    args: string[],
+    ctx: ShellContext,
+    opts?: { isFork?: boolean },
+  ) => Promise<ShellResult>;
+  evalCode: (code: string, ctx: ShellContext) => ShellResult;
+  printCode: (code: string, ctx: ShellContext) => ShellResult;
+  removeNodeModules: (cwd: string) => void;
+  formatErr: (msg: string, pm: PkgManager) => string;
+  formatWarn: (msg: string, pm: PkgManager) => string;
+  hasFile: (path: string) => boolean;
+  readFile: (path: string) => string;
+  writeFile: (path: string, data: string) => void;
+  npmPkg?: (args: string[], ctx: ShellContext) => ShellResult;
+}

package/src/shell/commands/pnpm.ts

@@ -0,0 +1,82 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+import { VERSIONS } from "../../constants/config";
+
+const A_RESET = "\x1b[0m";
+const A_BOLD = "\x1b[1m";
+const A_CYAN = "\x1b[36m";
+
+export function createPnpmCommand(deps: PmDeps): ShellCommand {
+  return {
+    name: "pnpm",
+    async execute(params, ctx) {
+      if (!deps.hasFile("/"))
+        return { stdout: "", stderr: "Volume unavailable\n", exitCode: 1 };
+
+      const sub = params[0];
+      if (!sub || sub === "help" || sub === "--help") {
+        return {
+          stdout:
+            `${A_BOLD}Usage:${A_RESET} pnpm <command>\n\n` +
+            `${A_BOLD}Manage your dependencies:${A_RESET}\n` +
+            `  ${A_CYAN}add${A_RESET} [pkg]         Install packages\n` +
+            `  ${A_CYAN}install${A_RESET}           Install from manifest\n` +
+            `  ${A_CYAN}remove${A_RESET} <pkg>      Remove a package\n` +
+            `  ${A_CYAN}list${A_RESET}              List installed packages\n\n` +
+            `${A_BOLD}Run your scripts:${A_RESET}\n` +
+            `  ${A_CYAN}run${A_RESET} <script>      Run a script\n` +
+            `  ${A_CYAN}exec${A_RESET} <cmd>        Execute a package binary\n` +
+            `  ${A_CYAN}dlx${A_RESET} <pkg>         Download and execute a package\n\n` +
+            `${A_BOLD}Create a project:${A_RESET}\n` +
+            `  ${A_CYAN}init${A_RESET}              Create a package.json\n` +
+            `  ${A_CYAN}create${A_RESET} <pkg>      Create a project\n\n` +
+            `  ${A_CYAN}version${A_RESET}           Show version info\n`,
+          stderr: "",
+          exitCode: 0,
+        };
+      }
+
+      switch (sub) {
+        case "add":
+          return deps.installPackages(params.slice(1), ctx, "pnpm");
+        case "install":
+        case "i":
+          return deps.installPackages(params.slice(1), ctx, "pnpm");
+        case "remove":
+        case "rm":
+        case "uninstall":
+        case "un":
+          return deps.uninstallPackages(params.slice(1), ctx, "pnpm");
+        case "list":
+        case "ls":
+          return deps.listPackages(ctx, "pnpm");
+        case "run":
+          return deps.runScript(params.slice(1), ctx);
+        case "start":
+          return deps.runScript(["start"], ctx);
+        case "test":
+        case "t":
+          return deps.runScript(["test"], ctx);
+        case "exec":
+          return deps.npxExecute(params.slice(1), ctx);
+        case "dlx":
+          return deps.npxExecute(params.slice(1), ctx);
+        case "init":
+        case "create":
+          return deps.npmInitOrCreate(params.slice(1), sub, ctx);
+        case "version":
+        case "-v":
+        case "--version":
+          return { stdout: VERSIONS.PNPM + "\n", stderr: "", exitCode: 0 };
+        case "audit":
+          return { stdout: "No known vulnerabilities found\n", stderr: "", exitCode: 0 };
+        case "outdated":
+          return { stdout: "", stderr: "", exitCode: 0 };
+        case "why":
+          return { stdout: "", stderr: deps.formatWarn("why: not available in nodepod", "pnpm"), exitCode: 0 };
+        default:
+          return { stdout: "", stderr: deps.formatErr(`Unknown command "${sub}"`, "pnpm"), exitCode: 1 };
+      }
+    },
+  };
+}

package/src/shell/commands/search.ts

@@ -0,0 +1,264 @@
+import type { BuiltinFn } from "../shell-types";
+import { ok, fail, resolvePath, globToRegex } from "../shell-helpers";
+import { LS_BLOCK_SIZE } from "../../constants/config";
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+function matchSize(fileSize: number, spec: string): boolean {
+  const m = spec.match(/^([+-]?)(\d+)([cwbkMG]?)$/);
+  if (!m) return true;
+  const op = m[1];
+  let n = parseInt(m[2]);
+  const unit = m[3];
+  if (unit === "c") {
+    /* bytes */
+  } else if (unit === "w") n *= 2;
+  else if (unit === "k") n *= 1024;
+  else if (unit === "M") n *= 1048576;
+  else if (unit === "G") n *= 1073741824;
+  else n *= LS_BLOCK_SIZE;
+
+  if (op === "+") return fileSize > n;
+  if (op === "-") return fileSize < n;
+  return fileSize === n;
+}
+
+function matchMtime(mtimeMs: number, spec: string): boolean {
+  const m = spec.match(/^([+-]?)(\d+)$/);
+  if (!m) return true;
+  const op = m[1];
+  const days = parseInt(m[2]);
+  const age = (Date.now() - mtimeMs) / 86400000;
+  if (op === "+") return age > days;
+  if (op === "-") return age < days;
+  return Math.floor(age) === days;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Commands                                                           */
+/* ------------------------------------------------------------------ */
+
+const find_cmd: BuiltinFn = async (args, ctx) => {
+  let searchDir = ctx.cwd;
+  let namePattern = "";
+  let inamePattern = "";
+  let pathPattern = "";
+  let typeFilter = "";
+  let maxDepth = Infinity;
+  let minDepth = 0;
+  let sizeFilter = "";
+  let mtimeFilter = "";
+  let execCmd = "";
+  let execArgs: string[] = [];
+  let deleteMode = false;
+  let print0 = false;
+  let printMode = true;
+  let emptyFilter = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "-name" && i + 1 < args.length) {
+      namePattern = args[++i];
+    } else if (a === "-iname" && i + 1 < args.length) {
+      inamePattern = args[++i];
+    } else if (a === "-path" || (a === "-wholename" && i + 1 < args.length)) {
+      pathPattern = args[++i];
+    } else if (a === "-type" && i + 1 < args.length) {
+      typeFilter = args[++i];
+    } else if (a === "-maxdepth" && i + 1 < args.length) {
+      maxDepth = parseInt(args[++i]);
+    } else if (a === "-mindepth" && i + 1 < args.length) {
+      minDepth = parseInt(args[++i]);
+    } else if (a === "-size" && i + 1 < args.length) {
+      sizeFilter = args[++i];
+    } else if (a === "-mtime" && i + 1 < args.length) {
+      mtimeFilter = args[++i];
+    } else if (a === "-empty") {
+      emptyFilter = true;
+    } else if (a === "-delete") {
+      deleteMode = true;
+      printMode = false;
+    } else if (a === "-print0") {
+      print0 = true;
+    } else if (a === "-print") {
+      printMode = true;
+    } else if (a === "-exec") {
+      const cmdParts: string[] = [];
+      i++;
+      while (i < args.length && args[i] !== ";") {
+        cmdParts.push(args[i]);
+        i++;
+      }
+      if (cmdParts.length > 0) {
+        execCmd = cmdParts[0];
+        execArgs = cmdParts.slice(1);
+        printMode = false;
+      }
+    } else if (!a.startsWith("-")) {
+      searchDir = resolvePath(a, ctx.cwd);
+    }
+  }
+
+  const nameRe = namePattern
+    ? new RegExp("^" + globToRegex(namePattern) + "$")
+    : null;
+  const inameRe = inamePattern
+    ? new RegExp("^" + globToRegex(inamePattern) + "$", "i")
+    : null;
+  const pathRe = pathPattern ? new RegExp(globToRegex(pathPattern)) : null;
+
+  const results: string[] = [];
+  let execOut = "";
+
+  const walk = (dir: string, depth: number) => {
+    if (depth > maxDepth) return;
+    try {
+      for (const name of ctx.volume.readdirSync(dir)) {
+        const full = dir === "/" ? `/${name}` : `${dir}/${name}`;
+        try {
+          const st = ctx.volume.statSync(full);
+          const isDir = st.isDirectory();
+          const isFile = st.isFile();
+
+          if (depth >= minDepth) {
+            let match = true;
+            if (typeFilter) {
+              if (typeFilter === "f" && !isFile) match = false;
+              if (typeFilter === "d" && !isDir) match = false;
+            }
+            if (nameRe && !nameRe.test(name)) match = false;
+            if (inameRe && !inameRe.test(name)) match = false;
+            if (pathRe && !pathRe.test(full)) match = false;
+            if (sizeFilter && isFile) {
+              const fileSize = ctx.volume.readFileSync(full).length;
+              if (!matchSize(fileSize, sizeFilter)) match = false;
+            }
+            if (mtimeFilter) {
+              const mtime = st.mtimeMs || Date.now();
+              if (!matchMtime(mtime, mtimeFilter)) match = false;
+            }
+            if (emptyFilter) {
+              if (isDir) {
+                try {
+                  if (ctx.volume.readdirSync(full).length > 0) match = false;
+                } catch {
+                  match = false;
+                }
+              } else if (isFile) {
+                if (ctx.volume.readFileSync(full).length > 0) match = false;
+              } else match = false;
+            }
+            if (match) results.push(full);
+          }
+          if (isDir) walk(full, depth + 1);
+        } catch {
+          /* skip */
+        }
+      }
+    } catch {
+      /* skip */
+    }
+  };
+
+  walk(searchDir, 1);
+
+  if (deleteMode) {
+    for (const path of results.reverse()) {
+      try {
+        const st = ctx.volume.statSync(path);
+        if (st.isDirectory()) ctx.volume.rmdirSync(path);
+        else ctx.volume.unlinkSync(path);
+      } catch {
+        /* */
+      }
+    }
+    return ok();
+  }
+
+  if (execCmd) {
+    for (const path of results) {
+      const expandedArgs = execArgs.map((a) => (a === "{}" ? path : a));
+      const fullCmd = [execCmd, ...expandedArgs].join(" ");
+      const result = await ctx.exec(fullCmd, { cwd: ctx.cwd, env: ctx.env });
+      execOut += result.stdout;
+    }
+    return ok(execOut);
+  }
+
+  if (print0) return ok(results.join("\0"));
+  if (printMode) return ok(results.join("\n") + (results.length ? "\n" : ""));
+  return ok();
+};
+
+const xargs_cmd: BuiltinFn = async (args, ctx, stdin) => {
+  if (!stdin) return ok();
+
+  let maxArgs = Infinity;
+  let placeholder = "";
+  let nullDelim = false;
+  const cmdParts: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-n" && i + 1 < args.length)
+      maxArgs = parseInt(args[++i]) || 1;
+    else if (args[i] === "-I" && i + 1 < args.length) placeholder = args[++i];
+    else if (args[i] === "-0" || args[i] === "--null") nullDelim = true;
+    else if (args[i] === "-t") {
+      /* */
+    } else cmdParts.push(args[i]);
+  }
+
+  if (cmdParts.length === 0) cmdParts.push("echo");
+
+  const delim = nullDelim ? "\0" : /\s+/;
+  const items = stdin.trim().split(delim).filter(Boolean);
+  const cmd = cmdParts.join(" ");
+  let out = "";
+  let err = "";
+  let lastCode = 0;
+
+  if (placeholder) {
+    for (const item of items) {
+      const expanded = cmd.replace(
+        new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+        item,
+      );
+      const result = await ctx.exec(expanded, { cwd: ctx.cwd, env: ctx.env });
+      out += result.stdout;
+      err += result.stderr;
+      lastCode = result.exitCode;
+    }
+  } else if (maxArgs < Infinity) {
+    for (let i = 0; i < items.length; i += maxArgs) {
+      const batch = items.slice(i, i + maxArgs).join(" ");
+      const result = await ctx.exec(`${cmd} ${batch}`, {
+        cwd: ctx.cwd,
+        env: ctx.env,
+      });
+      out += result.stdout;
+      err += result.stderr;
+      lastCode = result.exitCode;
+    }
+  } else {
+    const result = await ctx.exec(`${cmd} ${items.join(" ")}`, {
+      cwd: ctx.cwd,
+      env: ctx.env,
+    });
+    out += result.stdout;
+    err += result.stderr;
+    lastCode = result.exitCode;
+  }
+
+  return { stdout: out, stderr: err, exitCode: lastCode };
+};
+
+/* ------------------------------------------------------------------ */
+/*  Registry                                                           */
+/* ------------------------------------------------------------------ */
+
+export const searchCommands: [string, BuiltinFn][] = [
+  ["find", find_cmd],
+  ["xargs", xargs_cmd],
+];