@aria-cli/tools 1.0.0

package/tests/executors/shell-env-process.test.ts

@@ -0,0 +1,245 @@
+/**
+ * @aria/tools - process.env blocklist filtering tests (aria-zoa)
+ *
+ * Verifies that dangerous environment variables inherited from the host
+ * process.env are stripped before being passed to child processes.
+ *
+ * Key distinction: BLOCKED_ENV_VARS (injection vars like LD_PRELOAD) are
+ * stripped from ALL sources. BLOCKED_INPUT_ENV_VARS (PATH, HOME, etc.)
+ * are only stripped from tool-injected input, NOT from process.env.
+ */
+
+import { describe, it, expect, afterEach } from "vitest";
+import type { ToolContext } from "../../src/types.js";
+import { mergeEnv, BLOCKED_ENV_VARS, BLOCKED_INPUT_ENV_VARS } from "../../src/executors/shell.js";
+
+const createContext = (workingDir: string, env: Record<string, string> = {}): ToolContext => ({
+  workingDir,
+  env,
+  confirm: async () => true,
+});
+
+describe("process.env blocklist filtering (aria-zoa)", () => {
+  const savedEnvVars: Record<string, string | undefined> = {};
+
+  const setProcessEnv = (key: string, value: string) => {
+    if (!(key in savedEnvVars)) {
+      savedEnvVars[key] = process.env[key];
+    }
+    process.env[key] = value;
+  };
+
+  const deleteProcessEnv = (key: string) => {
+    if (!(key in savedEnvVars)) {
+      savedEnvVars[key] = process.env[key];
+    }
+    delete process.env[key];
+  };
+
+  afterEach(() => {
+    for (const [key, original] of Object.entries(savedEnvVars)) {
+      if (original === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = original;
+      }
+    }
+    for (const key of Object.keys(savedEnvVars)) {
+      delete savedEnvVars[key];
+    }
+  });
+
+  describe("strips BLOCKED_ENV_VARS (injection vars) from process.env", () => {
+    it("should strip LD_PRELOAD from process.env", () => {
+      setProcessEnv("LD_PRELOAD", "/tmp/evil.so");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("LD_PRELOAD");
+    });
+
+    it("should strip BASH_ENV from process.env", () => {
+      setProcessEnv("BASH_ENV", "/tmp/evil-bashrc.sh");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("BASH_ENV");
+    });
+
+    it("should strip LD_LIBRARY_PATH from process.env", () => {
+      setProcessEnv("LD_LIBRARY_PATH", "/tmp/evil-libs");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("LD_LIBRARY_PATH");
+    });
+
+    it("should strip DYLD_INSERT_LIBRARIES from process.env", () => {
+      setProcessEnv("DYLD_INSERT_LIBRARIES", "/tmp/evil.dylib");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("DYLD_INSERT_LIBRARIES");
+    });
+
+    it("should strip PROMPT_COMMAND from process.env", () => {
+      setProcessEnv("PROMPT_COMMAND", "curl http://evil.com");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("PROMPT_COMMAND");
+    });
+
+    it("should strip GIT_DIR from process.env", () => {
+      setProcessEnv("GIT_DIR", "/tmp/host-repo/.git");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("GIT_DIR");
+    });
+
+    it("should strip indexed git config vars from process.env", () => {
+      setProcessEnv("GIT_CONFIG_KEY_0", "core.bare");
+      setProcessEnv("GIT_CONFIG_VALUE_0", "true");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("GIT_CONFIG_KEY_0");
+      expect(result).not.toHaveProperty("GIT_CONFIG_VALUE_0");
+    });
+
+    it("should strip all BLOCKED_ENV_VARS from process.env", () => {
+      for (const varName of BLOCKED_ENV_VARS) {
+        setProcessEnv(varName, `evil_${varName.toLowerCase()}`);
+      }
+      const result = mergeEnv(createContext("/tmp"));
+      for (const varName of BLOCKED_ENV_VARS) {
+        expect(result).not.toHaveProperty(varName);
+      }
+    });
+
+    it("should strip git repo-context vars from process.env", () => {
+      setProcessEnv("GIT_DIR", "/tmp/not-repo");
+      setProcessEnv("GIT_WORK_TREE", "/tmp/not-repo");
+      setProcessEnv("GIT_CONFIG_GLOBAL", "/tmp/not-config");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("GIT_DIR");
+      expect(result).not.toHaveProperty("GIT_WORK_TREE");
+      expect(result).not.toHaveProperty("GIT_CONFIG_GLOBAL");
+    });
+
+    it("should strip git config injection prefix vars from process.env", () => {
+      setProcessEnv("GIT_CONFIG_COUNT", "1");
+      setProcessEnv("GIT_CONFIG_KEY_0", "user.name");
+      setProcessEnv("GIT_CONFIG_VALUE_0", "poisoned");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("GIT_CONFIG_COUNT");
+      expect(result).not.toHaveProperty("GIT_CONFIG_KEY_0");
+      expect(result).not.toHaveProperty("GIT_CONFIG_VALUE_0");
+    });
+  });
+
+  describe("preserves host PATH/HOME/NODE_OPTIONS from process.env", () => {
+    it("should preserve PATH from process.env (host PATH is legitimate)", () => {
+      setProcessEnv("PATH", "/usr/local/bin:/usr/bin:/bin");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result.PATH).toBe("/usr/local/bin:/usr/bin:/bin");
+    });
+
+    it("should preserve HOME from process.env (needed by git, ssh, etc.)", () => {
+      setProcessEnv("HOME", "/Users/testuser");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result.HOME).toBe("/Users/testuser");
+    });
+
+    it("should preserve NODE_OPTIONS from process.env (user config)", () => {
+      setProcessEnv("NODE_OPTIONS", "--max-old-space-size=4096");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result.NODE_OPTIONS).toBe("--max-old-space-size=4096");
+    });
+
+    it("should preserve SHELL from process.env", () => {
+      setProcessEnv("SHELL", "/bin/zsh");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result.SHELL).toBe("/bin/zsh");
+    });
+  });
+
+  describe("blocks BLOCKED_INPUT_ENV_VARS from tool-injected input", () => {
+    it("should block PATH from inputEnv", () => {
+      const result = mergeEnv(createContext("/tmp"), { PATH: "/tmp/evil-path" });
+      expect(result.PATH).not.toBe("/tmp/evil-path");
+    });
+
+    it("should block HOME from inputEnv", () => {
+      const result = mergeEnv(createContext("/tmp"), { HOME: "/tmp/evil-home" });
+      expect(result.HOME).not.toBe("/tmp/evil-home");
+    });
+
+    it("should block NODE_OPTIONS from inputEnv", () => {
+      const result = mergeEnv(createContext("/tmp"), {
+        NODE_OPTIONS: "--require /tmp/evil.js",
+      });
+      expect(result.NODE_OPTIONS).not.toBe("--require /tmp/evil.js");
+    });
+
+    it("should block PATH from ctx.env", () => {
+      const ctx = createContext("/tmp", { PATH: "/tmp/evil-path" });
+      const result = mergeEnv(ctx);
+      expect(result.PATH).not.toBe("/tmp/evil-path");
+    });
+
+    it("should block all BLOCKED_INPUT_ENV_VARS from inputEnv", () => {
+      const evilInput: Record<string, string> = {};
+      for (const varName of BLOCKED_INPUT_ENV_VARS) {
+        evilInput[varName] = `evil_${varName.toLowerCase()}`;
+      }
+      const result = mergeEnv(createContext("/tmp"), evilInput);
+      for (const varName of BLOCKED_INPUT_ENV_VARS) {
+        expect(result[varName]).not.toBe(`evil_${varName.toLowerCase()}`);
+      }
+    });
+
+    it("should block git context and identity vars from inputEnv", () => {
+      const result = mergeEnv(createContext("/tmp"), {
+        GIT_DIR: "/tmp/not-repo",
+        GIT_AUTHOR_NAME: "Injected",
+        GIT_COMMITTER_EMAIL: "evil@example.com",
+      });
+      expect(result).not.toHaveProperty("GIT_DIR");
+      expect(result).not.toHaveProperty("GIT_AUTHOR_NAME");
+      expect(result).not.toHaveProperty("GIT_COMMITTER_EMAIL");
+    });
+
+    it("should block git context vars from ctx.env", () => {
+      const ctx = createContext("/tmp", {
+        GIT_WORK_TREE: "/tmp/not-repo",
+        GIT_CONFIG_GLOBAL: "/tmp/not-config",
+      });
+      const result = mergeEnv(ctx);
+      expect(result).not.toHaveProperty("GIT_WORK_TREE");
+      expect(result).not.toHaveProperty("GIT_CONFIG_GLOBAL");
+    });
+  });
+
+  describe("passthrough of safe vars", () => {
+    it("should preserve TERM from process.env", () => {
+      setProcessEnv("TERM", "xterm-256color");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result.TERM).toBe("xterm-256color");
+    });
+
+    it("should preserve LANG from process.env", () => {
+      setProcessEnv("LANG", "en_US.UTF-8");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result.LANG).toBe("en_US.UTF-8");
+    });
+
+    it("should preserve custom non-blocked variable", () => {
+      setProcessEnv("ARIA_TEST_CANARY", "canary_value_12345");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result.ARIA_TEST_CANARY).toBe("canary_value_12345");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle absent process.env vars without crash", () => {
+      deleteProcessEnv("LD_PRELOAD");
+      const result = mergeEnv(createContext("/tmp"));
+      expect(result).not.toHaveProperty("LD_PRELOAD");
+    });
+
+    it("should return a plain object (not process.env reference)", () => {
+      const result = mergeEnv(createContext("/tmp"));
+      result["__ARIA_MUTATION_TEST__"] = "test";
+      expect(process.env.__ARIA_MUTATION_TEST__).toBeUndefined();
+      delete result["__ARIA_MUTATION_TEST__"];
+    });
+  });
+});

package/tests/executors/shell-process-registry.test.ts

@@ -0,0 +1,334 @@
+/**
+ * @aria/tools - Shell executor + SpawnedProcessRegistry integration tests
+ *
+ * Verifies that shell executors properly register/deregister PIDs
+ * in the SpawnedProcessRegistry via ToolContext.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { ToolContext } from "../../src/types.js";
+import { SpawnedProcessRegistry } from "../../src/executors/process-registry.js";
+import { executeBash, executeExec, executeSpawn, executeKill } from "../../src/executors/shell.js";
+
+const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+const waitForFile = async (filePath: string, timeoutMs = 5_000): Promise<void> => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      await fs.access(filePath);
+      return;
+    } catch {
+      await sleep(25);
+    }
+  }
+  throw new Error(`Timed out waiting for ${filePath}`);
+};
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const createTempDir = async (): Promise<string> => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-shell-reg-test-"));
+  return fs.realpath(tempDir);
+};
+
+const SIGTERM_IGNORING_NODE_SCRIPT =
+  "const fs = require('node:fs'); process.on('SIGTERM', () => {}); fs.writeFileSync(process.env.READY_FILE, 'ready'); setInterval(() => {}, 1000);";
+
+describe("Shell executors + SpawnedProcessRegistry", () => {
+  let tempDir: string;
+  let registry: SpawnedProcessRegistry;
+  let ctx: ToolContext;
+  const pidsToCleanup: number[] = [];
+
+  beforeEach(async () => {
+    tempDir = await createTempDir();
+    registry = new SpawnedProcessRegistry();
+    ctx = {
+      workingDir: tempDir,
+      env: {},
+      confirm: async () => true,
+      processRegistry: registry,
+    };
+  });
+
+  afterEach(async () => {
+    for (const pid of pidsToCleanup) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+        // Process may already be dead
+      }
+    }
+    pidsToCleanup.length = 0;
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("executeExec", () => {
+    it("registers PID on spawn and deregisters on normal exit", async () => {
+      // Run a quick command
+      const result = await executeExec({ program: "echo", args: ["hello"] }, ctx);
+
+      expect(result.success).toBe(true);
+      // After the command exits normally, PID should be deregistered
+      expect(registry.size).toBe(0);
+    });
+
+    it("registers PID on spawn and deregisters on non-zero exit", async () => {
+      const result = await executeExec({ program: "false" }, ctx);
+
+      expect(result.success).toBe(false);
+      // Even on failure, PID should be deregistered
+      expect(registry.size).toBe(0);
+    });
+
+    it("registers PID on spawn and deregisters on timeout", async () => {
+      const result = await executeExec({ program: "sleep", args: ["30"], timeout: 100 }, ctx);
+
+      expect(result.success).toBe(false);
+      // After timeout, PID should be deregistered
+      expect(registry.size).toBe(0);
+    }, 10000);
+  });
+
+  describe("executeBash", () => {
+    it("reports teardown-killed bash processes as failures instead of silent success", async () => {
+      const resultPromise = executeBash(
+        {
+          command: "sleep 60",
+        },
+        ctx,
+      );
+
+      await sleep(100);
+
+      expect(registry.size).toBe(1);
+      const [pid] = registry.getAll();
+      expect(typeof pid).toBe("number");
+      pidsToCleanup.push(pid!);
+      expect(isProcessAlive(pid!)).toBe(true);
+
+      await registry.killAll();
+      const result = await resultPromise;
+
+      expect(isProcessAlive(pid!)).toBe(false);
+      expect(registry.size).toBe(0);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("signal");
+    }, 15000);
+  });
+
+  describe("executeSpawn", () => {
+    it("registers PID of detached background process", async () => {
+      const result = await executeSpawn({ program: "sleep", args: ["60"] }, ctx);
+
+      expect(result.success).toBe(true);
+      const data = result.data as { pid: number };
+      pidsToCleanup.push(data.pid);
+
+      // PID should be tracked in registry (spawned process is still alive)
+      expect(registry.has(data.pid)).toBe(true);
+      expect(registry.size).toBe(1);
+
+      // Process should be alive
+      expect(isProcessAlive(data.pid)).toBe(true);
+    });
+
+    it("killAll cleans up spawned background processes", async () => {
+      const result = await executeSpawn({ program: "sleep", args: ["60"] }, ctx);
+      expect(result.success).toBe(true);
+      const data = result.data as { pid: number };
+      pidsToCleanup.push(data.pid);
+
+      expect(isProcessAlive(data.pid)).toBe(true);
+
+      // killAll should terminate the process
+      await registry.killAll();
+      await sleep(200);
+
+      expect(isProcessAlive(data.pid)).toBe(false);
+      expect(registry.size).toBe(0);
+    }, 10000);
+
+    it("killAll waits for SIGTERM-resistant spawned processes to exit", async () => {
+      const readyFile = path.join(tempDir, "sigterm-resistant-ready");
+      const result = await executeSpawn(
+        {
+          program: process.execPath,
+          args: ["-e", SIGTERM_IGNORING_NODE_SCRIPT],
+          env: {
+            READY_FILE: readyFile,
+          },
+        },
+        ctx,
+      );
+
+      expect(result.success).toBe(true);
+      const { pid } = result.data as { pid: number };
+      pidsToCleanup.push(pid);
+      await waitForFile(readyFile);
+
+      const startedAt = Date.now();
+      await registry.killAll();
+      const elapsedMs = Date.now() - startedAt;
+
+      expect(elapsedMs).toBeGreaterThanOrEqual(1900);
+      expect(isProcessAlive(pid)).toBe(false);
+      expect(registry.getProcess(pid)).toMatchObject({
+        pid,
+        status: "exited",
+        signal: "SIGKILL",
+      });
+    }, 15000);
+
+    it("killAll terminates detached process groups, not just the tracked leader pid", async () => {
+      const childPidFile = path.join(tempDir, "child-pid");
+      const result = await executeSpawn(
+        {
+          program: "sh",
+          args: ["-c", 'sleep 60 & child=$!; echo "$child" > "$CHILD_PID_FILE"; wait "$child"'],
+          env: {
+            CHILD_PID_FILE: childPidFile,
+          },
+        },
+        ctx,
+      );
+
+      expect(result.success).toBe(true);
+      const { pid } = result.data as { pid: number };
+      pidsToCleanup.push(pid);
+      await waitForFile(childPidFile);
+      const childPid = Number.parseInt((await fs.readFile(childPidFile, "utf8")).trim(), 10);
+
+      expect(isProcessAlive(pid)).toBe(true);
+      expect(isProcessAlive(childPid)).toBe(true);
+
+      await registry.killAll();
+      await sleep(200);
+
+      expect(isProcessAlive(pid)).toBe(false);
+      expect(isProcessAlive(childPid)).toBe(false);
+    }, 15000);
+
+    it("reaps detached process groups after the leader exits but the last child drains naturally", async () => {
+      const result = await executeSpawn(
+        {
+          program: process.execPath,
+          args: [
+            "-e",
+            [
+              "const { spawn } = require('node:child_process');",
+              "const child = spawn('sleep', ['1'], { stdio: 'ignore' });",
+              "child.unref();",
+              "setTimeout(() => process.exit(0), 20);",
+            ].join(" "),
+          ],
+        },
+        ctx,
+      );
+
+      expect(result.success).toBe(true);
+      const { pid } = result.data as { pid: number };
+      pidsToCleanup.push(pid);
+
+      expect(registry.has(pid)).toBe(true);
+      await sleep(1_500);
+
+      expect(registry.has(pid)).toBe(false);
+      expect(registry.getProcess(pid)).toMatchObject({
+        pid,
+        status: "exited",
+      });
+    }, 15_000);
+  });
+
+  describe("executeKill", () => {
+    it("keeps a terminating pid tracked until exit is observed", async () => {
+      // Spawn a background process
+      const spawnResult = await executeSpawn({ program: "sleep", args: ["60"] }, ctx);
+      expect(spawnResult.success).toBe(true);
+      const { pid } = spawnResult.data as { pid: number };
+      pidsToCleanup.push(pid);
+
+      expect(registry.has(pid)).toBe(true);
+
+      // Kill it via executeKill
+      const killResult = await executeKill({ pid }, ctx);
+      expect(killResult.success).toBe(true);
+
+      await sleep(50);
+      expect(registry.has(pid)).toBe(false);
+      expect(registry.size).toBe(0);
+    });
+
+    it("keeps SIGTERM-resistant processes tracked so killAll can escalate later", async () => {
+      const readyFile = path.join(tempDir, "kill-resistant-ready");
+      const spawnResult = await executeSpawn(
+        {
+          program: process.execPath,
+          args: ["-e", SIGTERM_IGNORING_NODE_SCRIPT],
+          env: {
+            READY_FILE: readyFile,
+          },
+        },
+        ctx,
+      );
+      expect(spawnResult.success).toBe(true);
+      const { pid } = spawnResult.data as { pid: number };
+      pidsToCleanup.push(pid);
+      await waitForFile(readyFile);
+
+      const killResult = await executeKill({ pid }, ctx);
+      expect(killResult.success).toBe(true);
+      expect(registry.has(pid)).toBe(true);
+      expect(isProcessAlive(pid)).toBe(true);
+
+      await registry.killAll();
+      expect(isProcessAlive(pid)).toBe(false);
+      expect(registry.getProcess(pid)).toMatchObject({
+        pid,
+        status: "exited",
+        signal: "SIGKILL",
+      });
+    }, 15000);
+  });
+
+  describe("without registry (backward compat)", () => {
+    it("executeExec works without processRegistry in context", async () => {
+      const ctxNoRegistry: ToolContext = {
+        workingDir: tempDir,
+        env: {},
+        confirm: async () => true,
+        // No processRegistry
+      };
+
+      const result = await executeExec({ program: "echo", args: ["test"] }, ctxNoRegistry);
+      expect(result.success).toBe(true);
+    });
+
+    it("executeSpawn works without processRegistry in context", async () => {
+      const ctxNoRegistry: ToolContext = {
+        workingDir: tempDir,
+        env: {},
+        confirm: async () => true,
+      };
+
+      const result = await executeSpawn({ program: "sleep", args: ["60"] }, ctxNoRegistry);
+      expect(result.success).toBe(true);
+      const { pid } = result.data as { pid: number };
+      pidsToCleanup.push(pid);
+
+      // Should still work, just no tracking
+      expect(isProcessAlive(pid)).toBe(true);
+    });
+  });
+});