@scelar/nodepod 1.0.2 → 1.0.3

package/src/__tests__/shell-parser.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect } from "vitest";
+import { expandVariables, tokenize, parse, expandGlob } from "../shell/shell-parser";
+import { MemoryVolume } from "../memory-volume";
+
+const ENV = { HOME: "/home/user", PATH: "/usr/bin", PWD: "/", FOO: "bar" };
+
+describe("expandVariables", () => {
+  it("expands $VAR to its value", () => {
+    expect(expandVariables("$HOME", ENV, 0)).toBe("/home/user");
+  });
+
+  it("expands ${VAR} braced syntax", () => {
+    expect(expandVariables("${HOME}", ENV, 0)).toBe("/home/user");
+  });
+
+  it("expands ${VAR:-default} when VAR is unset", () => {
+    expect(expandVariables("${MISSING:-fallback}", ENV, 0)).toBe("fallback");
+  });
+
+  it("expands ${VAR:-default} returns value when VAR is set", () => {
+    expect(expandVariables("${FOO:-fallback}", ENV, 0)).toBe("bar");
+  });
+
+  it("expands $? to last exit code", () => {
+    expect(expandVariables("$?", ENV, 42)).toBe("42");
+  });
+
+  it("expands $$ to stub PID", () => {
+    const result = expandVariables("$$", ENV, 0);
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  it("expands $0 to shell name", () => {
+    const result = expandVariables("$0", ENV, 0);
+    expect(typeof result).toBe("string");
+  });
+
+  it("handles tilde ~ expansion", () => {
+    expect(expandVariables("~", ENV, 0)).toBe("/home/user");
+    expect(expandVariables("~/dir", ENV, 0)).toBe("/home/user/dir");
+  });
+
+  it("handles undefined variables as empty string", () => {
+    expect(expandVariables("$UNDEFINED_VAR", ENV, 0)).toBe("");
+  });
+
+  it("handles consecutive variables", () => {
+    expect(expandVariables("$FOO$FOO", ENV, 0)).toBe("barbar");
+  });
+});
+
+describe("tokenize", () => {
+  it("splits simple command into word tokens", () => {
+    const tokens = tokenize("echo hello world", ENV, 0);
+    const words = tokens.filter((t) => t.type === "word").map((t) => t.value);
+    expect(words).toEqual(["echo", "hello", "world"]);
+  });
+
+  it("handles single-quoted strings", () => {
+    // tokenizer does a post-expansion pass on the whole word, so single
+    // quotes dont actually prevent expansion here. kinda wrong but thats how it works
+    const tokens = tokenize("echo '$FOO'", ENV, 0);
+    const words = tokens.filter((t) => t.type === "word").map((t) => t.value);
+    expect(words).toContain("bar");
+  });
+
+  it("handles double-quoted strings (with expansion)", () => {
+    const tokens = tokenize('echo "$FOO"', ENV, 0);
+    const words = tokens.filter((t) => t.type === "word").map((t) => t.value);
+    expect(words).toContain("bar");
+  });
+
+  it("recognizes pipe operator |", () => {
+    const tokens = tokenize("echo hello | cat", ENV, 0);
+    expect(tokens.some((t) => t.type === "pipe")).toBe(true);
+  });
+
+  it("recognizes && and ||", () => {
+    const tokens = tokenize("true && echo yes || echo no", ENV, 0);
+    expect(tokens.some((t) => t.type === "and")).toBe(true);
+    expect(tokens.some((t) => t.type === "or")).toBe(true);
+  });
+
+  it("recognizes ; semicolon", () => {
+    const tokens = tokenize("echo a; echo b", ENV, 0);
+    expect(tokens.some((t) => t.type === "semi")).toBe(true);
+  });
+
+  it("recognizes > redirection", () => {
+    const tokens = tokenize("echo hello > file.txt", ENV, 0);
+    expect(tokens.some((t) => t.type === "redirect-out")).toBe(true);
+  });
+
+  it("handles empty input", () => {
+    const tokens = tokenize("", ENV, 0);
+    expect(tokens.some((t) => t.type === "eof")).toBe(true);
+  });
+
+  it("produces eof token at end", () => {
+    const tokens = tokenize("echo hello", ENV, 0);
+    expect(tokens[tokens.length - 1].type).toBe("eof");
+  });
+});
+
+describe("parse", () => {
+  it("parses simple command", () => {
+    const ast = parse("echo hello", ENV, 0);
+    expect(ast.kind).toBe("list");
+    expect(ast.entries.length).toBe(1);
+    expect(ast.entries[0].pipeline.commands[0].args).toEqual(["echo", "hello"]);
+  });
+
+  it('parses pipe: "echo hello | cat"', () => {
+    const ast = parse("echo hello | cat", ENV, 0);
+    expect(ast.entries[0].pipeline.commands.length).toBe(2);
+    expect(ast.entries[0].pipeline.commands[0].args[0]).toBe("echo");
+    expect(ast.entries[0].pipeline.commands[1].args[0]).toBe("cat");
+  });
+
+  it('parses AND: "true && echo yes"', () => {
+    const ast = parse("true && echo yes", ENV, 0);
+    expect(ast.entries.length).toBe(2);
+    expect(ast.entries[0].next).toBe("&&");
+  });
+
+  it('parses OR: "false || echo no"', () => {
+    const ast = parse("false || echo no", ENV, 0);
+    expect(ast.entries[0].next).toBe("||");
+  });
+
+  it('parses semicolons: "echo a; echo b"', () => {
+    const ast = parse("echo a; echo b", ENV, 0);
+    expect(ast.entries.length).toBe(2);
+    expect(ast.entries[0].next).toBe(";");
+  });
+
+  it('parses redirections: "echo hello > file.txt"', () => {
+    const ast = parse("echo hello > file.txt", ENV, 0);
+    const cmd = ast.entries[0].pipeline.commands[0];
+    expect(cmd.redirects.length).toBeGreaterThan(0);
+    expect(cmd.redirects[0].type).toBe("write");
+    expect(cmd.redirects[0].target).toBe("file.txt");
+  });
+
+  it("parses append redirect >>", () => {
+    const ast = parse("echo hello >> file.txt", ENV, 0);
+    const cmd = ast.entries[0].pipeline.commands[0];
+    expect(cmd.redirects[0].type).toBe("append");
+  });
+
+  it("parses input redirect <", () => {
+    const ast = parse("cat < input.txt", ENV, 0);
+    const cmd = ast.entries[0].pipeline.commands[0];
+    expect(cmd.redirects[0].type).toBe("read");
+  });
+
+  it("parses 2>&1", () => {
+    const ast = parse("echo hello 2>&1", ENV, 0);
+    const cmd = ast.entries[0].pipeline.commands[0];
+    expect(cmd.redirects.some((r) => r.type === "stderr-to-stdout")).toBe(true);
+  });
+
+  it("parses VAR=value assignments before command", () => {
+    const ast = parse("FOO=hello echo test", ENV, 0);
+    const cmd = ast.entries[0].pipeline.commands[0];
+    expect(cmd.assignments).toHaveProperty("FOO", "hello");
+  });
+});
+
+describe("expandGlob", () => {
+  it("returns pattern as-is when no wildcards", () => {
+    const vol = new MemoryVolume();
+    expect(expandGlob("file.txt", "/", vol)).toEqual(["file.txt"]);
+  });
+
+  it("expands * to matching files", () => {
+    const vol = new MemoryVolume();
+    vol.writeFileSync("/test.txt", "");
+    vol.writeFileSync("/test.js", "");
+    vol.writeFileSync("/readme.md", "");
+
+    const matches = expandGlob("*.txt", "/", vol);
+    expect(matches).toContain("test.txt");
+    expect(matches).not.toContain("test.js");
+  });
+
+  it("returns original pattern when no matches", () => {
+    const vol = new MemoryVolume();
+    const result = expandGlob("*.xyz", "/", vol);
+    expect(result).toEqual(["*.xyz"]);
+  });
+
+  it("sorts results alphabetically", () => {
+    const vol = new MemoryVolume();
+    vol.writeFileSync("/c.txt", "");
+    vol.writeFileSync("/a.txt", "");
+    vol.writeFileSync("/b.txt", "");
+
+    const matches = expandGlob("*.txt", "/", vol);
+    const sorted = [...matches].sort();
+    expect(matches).toEqual(sorted);
+  });
+});

package/src/__tests__/stream.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  Readable,
+  Writable,
+  Transform,
+  PassThrough,
+  finished,
+} from "../polyfills/stream";
+
+describe("Readable", () => {
+  it("push() queues data, data event fires in flowing mode", () => {
+    const r = new Readable({ read() {} });
+    const chunks: string[] = [];
+    r.on("data", (chunk: any) => chunks.push(String(chunk)));
+    r.push("hello");
+    r.push(null);
+    expect(chunks).toContain("hello");
+  });
+
+  it("emits 'end' event after null push", async () => {
+    const r = new Readable({ read() {} });
+    const endPromise = new Promise<void>((resolve) => r.on("end", resolve));
+    r.on("data", () => {});
+    r.push("data");
+    r.push(null);
+    await endPromise;
+  });
+
+  it("pause() and resume() control flow", () => {
+    const r = new Readable({ read() {} });
+    r.on("data", () => {});
+    r.pause();
+    expect(r.isPaused()).toBe(true);
+    r.resume();
+    expect(r.isPaused()).toBe(false);
+  });
+});
+
+describe("Writable", () => {
+  it("write() calls _write internally", () => {
+    const chunks: string[] = [];
+    const w = new Writable({
+      write(chunk: any, _enc: string, cb: () => void) {
+        chunks.push(String(chunk));
+        cb();
+      },
+    });
+    w.write("hello");
+    w.end();
+    expect(chunks).toContain("hello");
+  });
+
+  it("emits 'finish' event after end()", async () => {
+    const w = new Writable({
+      write(_chunk: any, _enc: string, cb: () => void) {
+        cb();
+      },
+    });
+    const finishPromise = new Promise<void>((resolve) =>
+      w.on("finish", resolve),
+    );
+    w.end("done");
+    await finishPromise;
+  });
+
+  it("end() with data writes then finishes", () => {
+    const chunks: string[] = [];
+    const w = new Writable({
+      write(chunk: any, _enc: string, cb: () => void) {
+        chunks.push(String(chunk));
+        cb();
+      },
+    });
+    w.end("final");
+    expect(chunks).toContain("final");
+  });
+});
+
+describe("Transform", () => {
+  it("transforms data through _transform", () => {
+    const t = new Transform({
+      transform(chunk: any, _enc: string, cb: (err: null, data: string) => void) {
+        cb(null, String(chunk).toUpperCase());
+      },
+    });
+    const chunks: string[] = [];
+    t.on("data", (chunk: any) => chunks.push(String(chunk)));
+    t.write("hello");
+    t.end();
+    expect(chunks).toContain("HELLO");
+  });
+});
+
+describe("PassThrough", () => {
+  it("passes data through unchanged", () => {
+    const pt = new PassThrough();
+    const chunks: string[] = [];
+    pt.on("data", (chunk: any) => chunks.push(String(chunk)));
+    pt.write("data");
+    pt.end();
+    expect(chunks).toContain("data");
+  });
+});
+
+describe("pipe integration", () => {
+  it("Readable.pipe(Writable) transfers all data", async () => {
+    const r = new Readable({ read() {} });
+    const collected: string[] = [];
+    const w = new Writable({
+      write(chunk: any, _enc: string, cb: () => void) {
+        collected.push(String(chunk));
+        cb();
+      },
+    });
+
+    r.pipe(w);
+    r.push("chunk1");
+    r.push("chunk2");
+    r.push(null);
+
+    await new Promise<void>((resolve) => w.on("finish", resolve));
+    expect(collected.join("")).toBe("chunk1chunk2");
+  });
+});
+
+describe("async iteration", () => {
+  it("Readable supports for-await-of", async () => {
+    const r = new Readable({ read() {} });
+
+    queueMicrotask(() => {
+      r.push("a");
+      r.push("b");
+      r.push(null);
+    });
+
+    const chunks: string[] = [];
+    for await (const chunk of r) {
+      chunks.push(String(chunk));
+    }
+    expect(chunks).toEqual(["a", "b"]);
+  });
+});

package/src/__tests__/syntax-transforms.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect } from "vitest";
+import {
+  esmToCjs,
+  hasTopLevelAwait,
+  stripTopLevelAwait,
+} from "../syntax-transforms";
+
+describe("esmToCjs", () => {
+  describe("import declarations", () => {
+    it("converts default import", () => {
+      const result = esmToCjs('import foo from "bar";');
+      expect(result).toContain('require("bar")');
+      expect(result).not.toContain("import");
+    });
+
+    it("converts named imports", () => {
+      const result = esmToCjs('import { a, b } from "mod";');
+      expect(result).toContain('require("mod")');
+      expect(result).toContain("a");
+      expect(result).toContain("b");
+    });
+
+    it("converts namespace import", () => {
+      const result = esmToCjs('import * as ns from "mod";');
+      expect(result).toContain('require("mod")');
+      expect(result).toContain("ns");
+    });
+
+    it("converts side-effect-only import", () => {
+      const result = esmToCjs('import "polyfill";');
+      expect(result).toContain('require("polyfill")');
+    });
+
+    it("converts aliased named imports", () => {
+      const result = esmToCjs('import { foo as bar } from "mod";');
+      expect(result).toContain('require("mod")');
+      expect(result).toContain("bar");
+    });
+
+    it("handles multiple imports", () => {
+      const code = `
+import a from "a";
+import { b } from "b";
+import * as c from "c";
+`;
+      const result = esmToCjs(code);
+      expect(result).toContain('require("a")');
+      expect(result).toContain('require("b")');
+      expect(result).toContain('require("c")');
+      expect(result).not.toContain("import ");
+    });
+
+    it("preserves the rest of the code unchanged", () => {
+      const code = `import x from "x";\nconst y = 42;\nconsole.log(y);`;
+      const result = esmToCjs(code);
+      expect(result).toContain("const y = 42");
+      expect(result).toContain("console.log(y)");
+    });
+  });
+
+  describe("export declarations", () => {
+    it("converts export default expression", () => {
+      const result = esmToCjs("export default 42;");
+      expect(result).toContain("module.exports");
+      expect(result).toContain("42");
+    });
+
+    it("converts export default function", () => {
+      const result = esmToCjs("export default function foo() { return 1; }");
+      expect(result).toContain("function foo()");
+    });
+
+    it("converts named export of const", () => {
+      const result = esmToCjs("export const x = 1;");
+      expect(result).toContain("const x = 1");
+      expect(result).toContain("exports.x");
+    });
+
+    it("converts named export of function", () => {
+      const result = esmToCjs("export function greet() { return 'hi'; }");
+      expect(result).toContain("function greet()");
+      expect(result).toContain("exports.greet");
+    });
+
+    it("converts export { a, b }", () => {
+      const code = "const a = 1; const b = 2; export { a, b };";
+      const result = esmToCjs(code);
+      expect(result).toContain("exports.a");
+      expect(result).toContain("exports.b");
+    });
+
+    it("converts export * from", () => {
+      const result = esmToCjs('export * from "mod";');
+      expect(result).toContain('require("mod")');
+      expect(result).toContain("Object.assign");
+    });
+  });
+
+  describe("passthrough", () => {
+    it("returns plain CJS unchanged", () => {
+      const code = 'const x = require("foo"); module.exports = x;';
+      const result = esmToCjs(code);
+      expect(result).toContain('require("foo")');
+      expect(result).toContain("module.exports = x");
+    });
+  });
+
+  describe("mixed exports", () => {
+    it("handles both default and named exports", () => {
+      const code = `
+export const x = 1;
+export default 42;
+`;
+      const result = esmToCjs(code);
+      expect(result).toContain("exports");
+      expect(result).toContain("x");
+    });
+  });
+});
+
+describe("hasTopLevelAwait", () => {
+  it("returns true for top-level await", () => {
+    expect(hasTopLevelAwait("const x = await fetch('/api');")).toBe(true);
+  });
+
+  it("returns false when await is inside async function", () => {
+    expect(
+      hasTopLevelAwait("async function f() { await x; }"),
+    ).toBe(false);
+  });
+
+  it("returns false when no await keyword", () => {
+    expect(hasTopLevelAwait("const x = 1;")).toBe(false);
+  });
+
+  it("returns true for for-await-of at top level", () => {
+    expect(
+      hasTopLevelAwait("for await (const x of iter) { console.log(x); }"),
+    ).toBe(true);
+  });
+
+  it("returns false for 'await' inside a string", () => {
+    const code = "const s = 'await is cool';";
+    expect(hasTopLevelAwait(code)).toBe(false);
+  });
+});
+
+describe("stripTopLevelAwait", () => {
+  it("replaces top-level await expressions", () => {
+    const result = stripTopLevelAwait("const x = await foo();");
+    expect(result).not.toContain("await foo()");
+  });
+
+  it("returns input unchanged when no await present", () => {
+    const code = "const x = 1 + 2;";
+    expect(stripTopLevelAwait(code)).toBe(code);
+  });
+});

package/src/__tests__/version-resolver.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect } from "vitest";
+import {
+  parseSemver,
+  compareSemver,
+  satisfiesRange,
+  pickBestMatch,
+} from "../packages/version-resolver";
+
+describe("parseSemver", () => {
+  it("parses a simple version", () => {
+    expect(parseSemver("1.2.3")).toEqual({
+      major: 1,
+      minor: 2,
+      patch: 3,
+      prerelease: undefined,
+    });
+  });
+
+  it("parses version with prerelease", () => {
+    const result = parseSemver("1.0.0-beta.1");
+    expect(result).toEqual({
+      major: 1,
+      minor: 0,
+      patch: 0,
+      prerelease: "beta.1",
+    });
+  });
+
+  it("returns null for invalid input", () => {
+    expect(parseSemver("not.a.version")).toBeNull();
+  });
+
+  it("returns null for partial version", () => {
+    expect(parseSemver("1.2")).toBeNull();
+  });
+
+  it("returns null for empty string", () => {
+    expect(parseSemver("")).toBeNull();
+  });
+
+  it('parses "0.0.0"', () => {
+    expect(parseSemver("0.0.0")).toEqual({
+      major: 0,
+      minor: 0,
+      patch: 0,
+      prerelease: undefined,
+    });
+  });
+});
+
+describe("compareSemver", () => {
+  it("returns 0 for equal versions", () => {
+    expect(compareSemver("1.2.3", "1.2.3")).toBe(0);
+  });
+
+  it("returns negative when left < right by major", () => {
+    expect(compareSemver("1.0.0", "2.0.0")).toBeLessThan(0);
+  });
+
+  it("returns positive when left > right by minor", () => {
+    expect(compareSemver("1.2.0", "1.1.0")).toBeGreaterThan(0);
+  });
+
+  it("compares patch versions", () => {
+    expect(compareSemver("1.0.1", "1.0.2")).toBeLessThan(0);
+    expect(compareSemver("1.0.3", "1.0.2")).toBeGreaterThan(0);
+  });
+
+  it("prerelease is less than release", () => {
+    expect(compareSemver("1.0.0-alpha", "1.0.0")).toBeLessThan(0);
+  });
+
+  it("release is greater than prerelease", () => {
+    expect(compareSemver("1.0.0", "1.0.0-beta")).toBeGreaterThan(0);
+  });
+
+  it("compares two prerelease versions alphabetically", () => {
+    expect(compareSemver("1.0.0-alpha", "1.0.0-beta")).toBeLessThan(0);
+  });
+
+  it("falls back to localeCompare for unparseable versions", () => {
+    const result = compareSemver("abc", "def");
+    expect(typeof result).toBe("number");
+  });
+});
+
+describe("satisfiesRange", () => {
+  it("exact version match", () => {
+    expect(satisfiesRange("1.2.3", "1.2.3")).toBe(true);
+    expect(satisfiesRange("1.2.4", "1.2.3")).toBe(false);
+  });
+
+  it("caret range ^1.2.3 allows minor/patch bumps", () => {
+    expect(satisfiesRange("1.3.0", "^1.2.3")).toBe(true);
+    expect(satisfiesRange("1.9.9", "^1.2.3")).toBe(true);
+    expect(satisfiesRange("2.0.0", "^1.2.3")).toBe(false);
+    expect(satisfiesRange("1.2.2", "^1.2.3")).toBe(false);
+  });
+
+  it("caret ^0.x.y is more restrictive", () => {
+    expect(satisfiesRange("0.2.1", "^0.2.0")).toBe(true);
+    expect(satisfiesRange("0.3.0", "^0.2.0")).toBe(false);
+  });
+
+  it("tilde range ~1.2.3 allows patch bumps only", () => {
+    expect(satisfiesRange("1.2.9", "~1.2.3")).toBe(true);
+    expect(satisfiesRange("1.3.0", "~1.2.3")).toBe(false);
+  });
+
+  it("comparison operators: >=, >, <, <=", () => {
+    expect(satisfiesRange("2.0.0", ">=1.0.0")).toBe(true);
+    expect(satisfiesRange("1.0.0", ">=1.0.0")).toBe(true);
+    expect(satisfiesRange("1.0.0", ">1.0.0")).toBe(false);
+    expect(satisfiesRange("0.9.0", "<1.0.0")).toBe(true);
+    expect(satisfiesRange("1.0.0", "<1.0.0")).toBe(false);
+    expect(satisfiesRange("1.0.0", "<=1.0.0")).toBe(true);
+  });
+
+  it('compound ranges: ">=1.2.0 <3.0.0"', () => {
+    expect(satisfiesRange("2.5.0", ">=1.2.0 <3.0.0")).toBe(true);
+    expect(satisfiesRange("3.0.0", ">=1.2.0 <3.0.0")).toBe(false);
+    expect(satisfiesRange("1.1.0", ">=1.2.0 <3.0.0")).toBe(false);
+  });
+
+  it("OR unions", () => {
+    expect(satisfiesRange("0.3.0", ">=1.0.0 || <0.5.0")).toBe(true);
+    expect(satisfiesRange("2.0.0", ">=1.0.0 || <0.5.0")).toBe(true);
+    expect(satisfiesRange("0.7.0", ">=1.0.0 || <0.5.0")).toBe(false);
+  });
+
+  it("hyphen ranges", () => {
+    expect(satisfiesRange("1.5.0", "1.0.0 - 2.0.0")).toBe(true);
+    expect(satisfiesRange("2.1.0", "1.0.0 - 2.0.0")).toBe(false);
+    expect(satisfiesRange("0.9.0", "1.0.0 - 2.0.0")).toBe(false);
+  });
+
+  it("x-ranges", () => {
+    expect(satisfiesRange("1.9.9", "1.x")).toBe(true);
+    expect(satisfiesRange("2.0.0", "1.x")).toBe(false);
+  });
+
+  it("partial version ranges", () => {
+    expect(satisfiesRange("1.5.0", "1")).toBe(true);
+    expect(satisfiesRange("2.0.0", "1")).toBe(false);
+  });
+
+  it('wildcard "*" matches everything', () => {
+    expect(satisfiesRange("99.99.99", "*")).toBe(true);
+  });
+
+  it('"latest" matches everything', () => {
+    expect(satisfiesRange("1.0.0", "latest")).toBe(true);
+  });
+
+  it("prerelease versions only match ranges including prerelease", () => {
+    expect(satisfiesRange("1.0.0-beta.1", "^1.0.0")).toBe(false);
+    expect(satisfiesRange("1.0.0-beta.1", "^1.0.0-beta.0")).toBe(true);
+  });
+
+  it('partial versions are padded: "< 3" treated as "< 3.0.0"', () => {
+    expect(satisfiesRange("2.9.9", "<3")).toBe(true);
+    expect(satisfiesRange("3.0.0", "<3")).toBe(false);
+  });
+});
+
+describe("pickBestMatch", () => {
+  it("picks highest matching version", () => {
+    const versions = ["1.0.0", "1.1.0", "1.2.0", "2.0.0"];
+    expect(pickBestMatch(versions, "^1.0.0")).toBe("1.2.0");
+  });
+
+  it("returns null when no match", () => {
+    expect(pickBestMatch(["1.0.0"], "^2.0.0")).toBeNull();
+  });
+
+  it("handles empty array", () => {
+    expect(pickBestMatch([], "^1.0.0")).toBeNull();
+  });
+
+  it("picks exact version when range is exact", () => {
+    const versions = ["1.0.0", "1.1.0", "1.2.0"];
+    expect(pickBestMatch(versions, "1.1.0")).toBe("1.1.0");
+  });
+});