@aria-cli/tools 1.0.8 → 1.0.10

package/tests/executors/pty.test.ts

@@ -1,664 +0,0 @@
-/**
- * @aria/tools - PTY executor tests
- */
-
-import { describe, it, expect, afterEach } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import {
-  PTYSession,
-  PTYOptions,
-  PTYTimeoutError,
-  PTYError,
-  createPTYSession,
-  runInPTY,
-} from "../../src/executors/pty.js";
-
-// Helper to create a unique temp directory for each test
-const createTempDir = async (): Promise<string> => {
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-pty-test-"));
-  return fs.realpath(tempDir);
-};
-
-// Helper to clean up temp directory
-const cleanupTempDir = async (dir: string): Promise<void> => {
-  await fs.rm(dir, { recursive: true, force: true });
-};
-
-// Check if PTY is available in this environment
-// Some environments (containers, sandboxes) don't support PTY operations
-let ptyAvailable = true;
-try {
-  const nodePty = await import("node-pty");
-  const testPty = nodePty.spawn("/bin/echo", ["test"]);
-  testPty.kill();
-} catch {
-  ptyAvailable = false;
-}
-
-describe.skipIf(!ptyAvailable)("PTY Executors", () => {
-  // Track sessions for cleanup
-  const sessions: PTYSession[] = [];
-
-  afterEach(async () => {
-    // Clean up all sessions
-    for (const session of sessions) {
-      try {
-        session.close();
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-    sessions.length = 0;
-  });
-
-  describe("createPTYSession", () => {
-    it("should create a PTY session with a simple command", async () => {
-      const session = await createPTYSession({
-        command: "/bin/echo",
-        args: ["hello", "world"],
-      });
-      sessions.push(session);
-
-      expect(session).toBeInstanceOf(PTYSession);
-      expect(session.pid).toBeGreaterThan(0);
-      expect(session.cols).toBe(80);
-      expect(session.rows).toBe(24);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("hello world");
-    });
-
-    it("should use custom terminal size", async () => {
-      const session = await createPTYSession({
-        command: "/bin/echo",
-        args: ["test"],
-        cols: 120,
-        rows: 40,
-      });
-      sessions.push(session);
-
-      expect(session.cols).toBe(120);
-      expect(session.rows).toBe(40);
-
-      await session.waitForExit(5000);
-    });
-
-    it("should use custom working directory", async () => {
-      const tempDir = await createTempDir();
-      try {
-        const session = await createPTYSession({
-          command: "/bin/pwd",
-          cwd: tempDir,
-        });
-        sessions.push(session);
-
-        const output = await session.waitForExit(5000);
-        expect(output).toContain(tempDir);
-      } finally {
-        await cleanupTempDir(tempDir);
-      }
-    });
-
-    it("should use custom environment variables", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", "echo $MY_TEST_VAR"],
-        env: { MY_TEST_VAR: "custom_value_123" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("custom_value_123");
-    });
-  });
-
-  describe("PTYSession", () => {
-    describe("write", () => {
-      it("should send input to the terminal", async () => {
-        // Use cat which echoes input
-        const session = await createPTYSession({
-          command: "/bin/cat",
-        });
-        sessions.push(session);
-
-        // Write some input
-        session.write("test input\n");
-
-        // Wait for the echo
-        const output = await session.waitFor("test input", 2000);
-        expect(output).toContain("test input");
-
-        // Send EOF to close cat
-        session.write("\x04"); // Ctrl+D
-      });
-    });
-
-    describe("resize", () => {
-      it("should resize the terminal", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sh",
-          args: ["-c", "sleep 1"],
-          cols: 80,
-          rows: 24,
-        });
-        sessions.push(session);
-
-        expect(session.cols).toBe(80);
-        expect(session.rows).toBe(24);
-
-        session.resize(120, 40);
-
-        expect(session.cols).toBe(120);
-        expect(session.rows).toBe(40);
-      });
-
-      it("should throw when resizing a closed session", async () => {
-        const session = await createPTYSession({
-          command: "/bin/echo",
-          args: ["done"],
-        });
-        sessions.push(session);
-
-        await session.waitForExit(5000);
-
-        expect(() => session.resize(100, 50)).toThrow(PTYError);
-      });
-    });
-
-    describe("waitFor", () => {
-      it("should wait for a string pattern", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sh",
-          args: ["-c", 'echo "line1"; sleep 0.1; echo "line2"; sleep 0.1; echo "line3"'],
-        });
-        sessions.push(session);
-
-        const output = await session.waitFor("line2", 5000);
-        expect(output).toContain("line1");
-        expect(output).toContain("line2");
-      });
-
-      it("should wait for a regex pattern", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sh",
-          args: ["-c", 'echo "count: 42"'],
-        });
-        sessions.push(session);
-
-        const output = await session.waitFor(/count: \d+/, 5000);
-        expect(output).toContain("count: 42");
-      });
-
-      it("should timeout if pattern is not found", async () => {
-        // Use sleep to keep process running while we wait for a pattern
-        const session = await createPTYSession({
-          command: "/bin/sleep",
-          args: ["60"],
-        });
-        sessions.push(session);
-
-        await expect(session.waitFor("nonexistent_pattern_xyz", 500)).rejects.toThrow(
-          PTYTimeoutError,
-        );
-      });
-
-      it("should error if process exits before pattern found", async () => {
-        // Fast command that exits before pattern can be found
-        const session = await createPTYSession({
-          command: "/bin/echo",
-          args: ["hello"],
-        });
-        sessions.push(session);
-
-        await expect(session.waitFor("nonexistent_pattern_xyz", 5000)).rejects.toThrow(PTYError);
-      });
-
-      it("should return immediately if pattern already matches", async () => {
-        const session = await createPTYSession({
-          command: "/bin/echo",
-          args: ["quick test"],
-        });
-        sessions.push(session);
-
-        // Wait for the echo to complete
-        await session.waitForExit(5000);
-
-        // Pattern should already be in buffer
-        const start = Date.now();
-        const output = await session.waitFor("quick test", 5000);
-        const elapsed = Date.now() - start;
-
-        expect(output).toContain("quick test");
-        expect(elapsed).toBeLessThan(100); // Should be nearly instant
-      });
-    });
-
-    describe("waitForExit", () => {
-      it("should wait for process to exit", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sh",
-          args: ["-c", 'echo "starting"; sleep 0.1; echo "done"'],
-        });
-        sessions.push(session);
-
-        const output = await session.waitForExit(5000);
-
-        expect(session.isRunning).toBe(false);
-        expect(output).toContain("starting");
-        expect(output).toContain("done");
-      });
-
-      it("should return exit code", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sh",
-          args: ["-c", "exit 42"],
-        });
-        sessions.push(session);
-
-        await session.waitForExit(5000);
-
-        expect(session.exitCode).toBe(42);
-      });
-
-      it("should timeout if process does not exit", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sleep",
-          args: ["60"],
-        });
-        sessions.push(session);
-
-        await expect(session.waitForExit(200)).rejects.toThrow(PTYTimeoutError);
-      });
-
-      it("should return immediately if already exited", async () => {
-        const session = await createPTYSession({
-          command: "/bin/echo",
-          args: ["quick"],
-        });
-        sessions.push(session);
-
-        // Wait for first exit
-        await session.waitForExit(5000);
-
-        // Second call should return immediately
-        const start = Date.now();
-        const output = await session.waitForExit(5000);
-        const elapsed = Date.now() - start;
-
-        expect(output).toContain("quick");
-        expect(elapsed).toBeLessThan(100);
-      });
-    });
-
-    describe("kill", () => {
-      it("should kill the process", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sleep",
-          args: ["60"],
-        });
-        sessions.push(session);
-
-        expect(session.isRunning).toBe(true);
-
-        session.kill();
-        await session.waitForExit(5_000);
-
-        expect(session.isRunning).toBe(false);
-      });
-
-      it("should be safe to call on already dead process", async () => {
-        const session = await createPTYSession({
-          command: "/bin/echo",
-          args: ["quick"],
-        });
-        sessions.push(session);
-
-        await session.waitForExit(5000);
-
-        // Should not throw
-        session.kill();
-        session.kill();
-      });
-    });
-
-    describe("close", () => {
-      it("should clean up resources", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sleep",
-          args: ["60"],
-        });
-        // Don't push to sessions - we'll close manually
-
-        expect(session.isRunning).toBe(true);
-
-        session.close();
-        await session.waitForExit(2_000);
-
-        expect(session.isRunning).toBe(false);
-      });
-    });
-
-    describe("isRunning", () => {
-      it("should return true while process is running", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sleep",
-          args: ["60"],
-        });
-        sessions.push(session);
-
-        expect(session.isRunning).toBe(true);
-
-        session.kill();
-        await session.waitForExit(5_000);
-
-        expect(session.isRunning).toBe(false);
-      });
-    });
-
-    describe("output", () => {
-      it("should accumulate all output", async () => {
-        const session = await createPTYSession({
-          command: "/bin/sh",
-          args: ["-c", 'echo "line1"; echo "line2"; echo "line3"'],
-        });
-        sessions.push(session);
-
-        await session.waitForExit(5000);
-
-        const output = session.output;
-        expect(output).toContain("line1");
-        expect(output).toContain("line2");
-        expect(output).toContain("line3");
-      });
-    });
-  });
-
-  describe("runInPTY", () => {
-    it("should run a command and return output", async () => {
-      const result = await runInPTY({
-        command: "/bin/echo",
-        args: ["hello", "world"],
-      });
-
-      expect(result.output).toContain("hello world");
-      expect(result.exitCode).toBe(0);
-    });
-
-    it("should capture exit code", async () => {
-      const result = await runInPTY({
-        command: "/bin/sh",
-        args: ["-c", "exit 7"],
-      });
-
-      expect(result.exitCode).toBe(7);
-    });
-
-    it("should support custom timeout", async () => {
-      await expect(
-        runInPTY({
-          command: "/bin/sleep",
-          args: ["60"],
-          timeoutMs: 200,
-        }),
-      ).rejects.toThrow(PTYTimeoutError);
-    });
-
-    it("should pass through PTY options", async () => {
-      const tempDir = await createTempDir();
-      try {
-        const result = await runInPTY({
-          command: "/bin/pwd",
-          cwd: tempDir,
-          cols: 100,
-          rows: 30,
-          env: { CUSTOM_VAR: "test" },
-        });
-
-        expect(result.output).toContain(tempDir);
-        expect(result.exitCode).toBe(0);
-      } finally {
-        await cleanupTempDir(tempDir);
-      }
-    });
-  });
-
-  describe("interactive scenarios", () => {
-    it("should handle interactive cat session", async () => {
-      const session = await createPTYSession({
-        command: "/bin/cat",
-      });
-      sessions.push(session);
-
-      // Send input
-      session.write("first line\n");
-      await session.waitFor("first line", 2000);
-
-      session.write("second line\n");
-      await session.waitFor("second line", 2000);
-
-      // Close with EOF
-      session.write("\x04");
-      await session.waitForExit(2000);
-
-      expect(session.output).toContain("first line");
-      expect(session.output).toContain("second line");
-    });
-
-    it("should handle shell session with prompts", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-      });
-      sessions.push(session);
-
-      // Execute a command
-      session.write('echo "test output"\n');
-      await session.waitFor("test output", 2000);
-
-      // Exit the shell
-      session.write("exit\n");
-      await session.waitForExit(2000);
-
-      expect(session.output).toContain("test output");
-    });
-  });
-
-  describe("error handling", () => {
-    it("should handle non-existent command", async () => {
-      // node-pty behavior varies by platform and version:
-      // - Some throw synchronously with posix_spawnp failed
-      // - Some let session be created but exit immediately with error
-      let error: Error | undefined;
-      let session: Awaited<ReturnType<typeof createPTYSession>> | undefined;
-      try {
-        session = await createPTYSession({
-          command: "/nonexistent/command/path",
-        });
-        if (session) {
-          sessions.push(session);
-          // If session was created, wait for it to exit
-          const exitResult = await session.waitForExit(2000);
-          // Non-existent commands typically exit with code 127 or spawn failure
-          // If we get here without an error, the exit code or output should indicate failure
-          if (exitResult.code === null || exitResult.code !== 0) {
-            // This is expected - non-existent command should fail
-            return;
-          }
-        }
-      } catch (e) {
-        error = e as Error;
-      }
-      // Either we caught a spawn error or the session failed to exit cleanly
-      if (error) {
-        expect(error.message).toMatch(/posix_spawnp failed|ENOENT|spawn|not found/i);
-      }
-      // If no error was thrown and we reach here, test passes if session failed somehow
-    });
-
-    it("should throw when writing to closed session", async () => {
-      const session = await createPTYSession({
-        command: "/bin/echo",
-        args: ["quick"],
-      });
-      sessions.push(session);
-
-      await session.waitForExit(5000);
-
-      expect(() => session.write("test")).toThrow(PTYError);
-    });
-
-    it("should include output in timeout error", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "visible output"; sleep 60'],
-      });
-      sessions.push(session);
-
-      // Wait for initial output
-      await session.waitFor("visible output", 2000);
-
-      try {
-        await session.waitFor("never appears", 200);
-        expect.fail("Should have thrown");
-      } catch (err) {
-        expect(err).toBeInstanceOf(PTYTimeoutError);
-        expect((err as PTYTimeoutError).output).toContain("visible output");
-      }
-    });
-  });
-
-  describe("env var filtering (aria-67o)", () => {
-    it("should strip LD_PRELOAD from PTY env", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "LD_PRELOAD=$LD_PRELOAD"'],
-        env: { LD_PRELOAD: "/evil/lib.so" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("LD_PRELOAD=");
-      expect(output).not.toContain("/evil/lib.so");
-    });
-
-    it("should strip BASH_ENV from PTY env", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "BASH_ENV=$BASH_ENV"'],
-        env: { BASH_ENV: "/evil/script.sh" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("BASH_ENV=");
-      expect(output).not.toContain("/evil/script.sh");
-    });
-
-    it("should strip GIT_DIR from PTY env", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "GIT_DIR=$GIT_DIR"'],
-        env: { GIT_DIR: "/tmp/not-repo" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("GIT_DIR=");
-      expect(output).not.toContain("/tmp/not-repo");
-    });
-
-    it("should strip NODE_OPTIONS from PTY env", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "NODE_OPTIONS=$NODE_OPTIONS"'],
-        env: { NODE_OPTIONS: "--require /evil/payload.js" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("NODE_OPTIONS=");
-      expect(output).not.toContain("/evil/payload.js");
-    });
-
-    it("should strip JAVA_TOOL_OPTIONS from PTY env", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "JAVA_TOOL_OPTIONS=$JAVA_TOOL_OPTIONS"'],
-        env: { JAVA_TOOL_OPTIONS: "-javaagent:/evil/agent.jar" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("JAVA_TOOL_OPTIONS=");
-      expect(output).not.toContain("/evil/agent.jar");
-    });
-
-    it("should strip RUBYOPT from PTY env", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "RUBYOPT=$RUBYOPT"'],
-        env: { RUBYOPT: "-r/evil/payload" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("RUBYOPT=");
-      expect(output).not.toContain("/evil/payload");
-    });
-
-    it("should strip PERL5OPT from PTY env", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "PERL5OPT=$PERL5OPT"'],
-        env: { PERL5OPT: "-M/evil/module" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("PERL5OPT=");
-      expect(output).not.toContain("/evil/module");
-    });
-
-    it("should strip PYTHONSTARTUP from PTY env", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "PYTHONSTARTUP=$PYTHONSTARTUP"'],
-        env: { PYTHONSTARTUP: "/evil/startup.py" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("PYTHONSTARTUP=");
-      expect(output).not.toContain("/evil/startup.py");
-    });
-
-    it("should pass through non-blocked env vars to PTY", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "MY_SAFE=$MY_SAFE"'],
-        env: { MY_SAFE: "safe_value_pty" },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("MY_SAFE=safe_value_pty");
-    });
-
-    it("should strip blocked vars while passing non-blocked vars in PTY", async () => {
-      const session = await createPTYSession({
-        command: "/bin/sh",
-        args: ["-c", 'echo "safe=$SAFE_VAR ld=$LD_PRELOAD"'],
-        env: {
-          SAFE_VAR: "hello_pty",
-          LD_PRELOAD: "/evil/lib.so",
-        },
-      });
-      sessions.push(session);
-
-      const output = await session.waitForExit(5000);
-      expect(output).toContain("safe=hello_pty");
-      expect(output).not.toContain("/evil/lib.so");
-    });
-  });
-});