@aria-cli/tools 1.0.0

package/tests/executors/pty.test.ts

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