@aria-cli/tools 1.0.0

package/tests/executors/shell-tools.test.ts

@@ -0,0 +1,393 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import {
+  executeBash,
+  executeSpawn,
+  executeKill,
+  executeListProcesses,
+  executeWaitProcess,
+} from "../../src/executors/shell.js";
+import { SpawnedProcessRegistry } from "../../src/executors/process-registry.js";
+import { PTYSessionStore } from "../../src/executors/pty-session-store.js";
+import * as ptyModule from "../../src/executors/pty.js";
+import type { ToolContext } from "../../src/types.js";
+
+describe("Shell Tool Executors", () => {
+  let tempDir: string;
+  let mockContext: ToolContext;
+  const pidsToCleanup: number[] = [];
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-shell-test-"));
+    mockContext = {
+      workingDir: tempDir,
+      env: {},
+      confirm: async () => true,
+    };
+  });
+
+  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 }).catch(() => {});
+  });
+
+  describe("executeBash", () => {
+    it("should execute command and return output", async () => {
+      const result = await executeBash(
+        { command: 'echo "Hello World"' },
+        mockContext,
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      const data = result.data as { stdout: string };
+      expect(data.stdout).toContain("Hello World");
+    });
+
+    it("should handle command failures", async () => {
+      const result = await executeBash({ command: "exit 1" }, mockContext);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toMatch(/exit.*code 1|failed/i);
+    });
+
+    it("should respect timeout", async () => {
+      const result = await executeBash(
+        { command: "sleep 10", timeout: 100 },
+        mockContext,
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.message).toMatch(/timed? ?out|SIGTERM/i);
+    }, 5000);
+
+    it("should set working directory", async () => {
+      const subDir = path.join(tempDir, "subdir");
+      await fs.mkdir(subDir);
+
+      const result = await executeBash(
+        { command: "pwd" },
+        { ...mockContext, workingDir: subDir },
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      const data = result.data as { stdout: string };
+      expect(data.stdout).toContain("subdir");
+    });
+
+    it("should pass custom environment variables to command", async () => {
+      const result = await executeBash(
+        {
+          command: "echo $CUSTOM_VAR",
+          env: { CUSTOM_VAR: "test123" },
+        },
+        mockContext,
+      );
+
+      expect(result.success).toBe(true);
+      const data = result.data as { stdout: string; stderr: string };
+      expect(data.stdout.trim()).toBe("test123");
+    });
+
+    it("should merge context env with command env", async () => {
+      const contextWithEnv: ToolContext = {
+        ...mockContext,
+        env: { BASE_VAR: "base" },
+      };
+
+      const result = await executeBash(
+        {
+          command: "echo $BASE_VAR $CUSTOM_VAR",
+          env: { CUSTOM_VAR: "custom" },
+        },
+        contextWithEnv,
+      );
+
+      expect(result.success).toBe(true);
+      const data = result.data as { stdout: string };
+      expect(data.stdout.trim()).toBe("base custom");
+    });
+  });
+
+  describe("process observability tools", () => {
+    it("list_processes should fail when process registry is unavailable", async () => {
+      const result = await executeListProcesses({}, mockContext);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("Process registry not available");
+    });
+
+    it("list_processes should return tracked process metadata", async () => {
+      const registry = new SpawnedProcessRegistry();
+      const ctxWithRegistry: ToolContext = {
+        ...mockContext,
+        processRegistry: registry,
+      };
+
+      const spawnResult = await executeSpawn({ program: "sleep", args: ["60"] }, ctxWithRegistry);
+      expect(spawnResult.success).toBe(true);
+
+      const { pid } = spawnResult.data as { pid: number };
+      pidsToCleanup.push(pid);
+
+      const result = await executeListProcesses({}, ctxWithRegistry);
+      expect(result.success).toBe(true);
+
+      const data = result.data as {
+        processes: Array<{
+          pid: number;
+          command: string;
+          args: string[];
+          cwd: string;
+          status: string;
+        }>;
+      };
+      const processInfo = data.processes.find((p) => p.pid === pid);
+      expect(processInfo).toBeDefined();
+      expect(processInfo).toMatchObject({
+        pid,
+        command: "sleep",
+        args: ["60"],
+        cwd: tempDir,
+        status: "running",
+      });
+    });
+
+    it("wait_process should fail when process registry is unavailable", async () => {
+      const result = await executeWaitProcess({ pid: 1234, timeoutMs: 100 }, mockContext);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("Process registry not available");
+    });
+
+    it("wait_process should return exit metadata when tracked process exits", async () => {
+      const registry = new SpawnedProcessRegistry();
+      const ctxWithRegistry: ToolContext = {
+        ...mockContext,
+        processRegistry: registry,
+      };
+
+      const spawnResult = await executeSpawn({ program: "sleep", args: ["1"] }, ctxWithRegistry);
+      expect(spawnResult.success).toBe(true);
+      const { pid } = spawnResult.data as { pid: number };
+
+      const result = await executeWaitProcess({ pid, timeoutMs: 5000 }, ctxWithRegistry);
+      expect(result.success).toBe(true);
+
+      const data = result.data as {
+        pid: number;
+        status: string;
+        exited: boolean;
+        timedOut: boolean;
+        waitedMs: number;
+        exitCode: number | null;
+      };
+      expect(data.pid).toBe(pid);
+      expect(data.status).toBe("exited");
+      expect(data.exited).toBe(true);
+      expect(data.timedOut).toBe(false);
+      expect(data.waitedMs).toBeGreaterThanOrEqual(0);
+      expect(data.exitCode).toBe(0);
+    }, 10000);
+
+    it("wait_process should timeout for running process", async () => {
+      const registry = new SpawnedProcessRegistry();
+      const ctxWithRegistry: ToolContext = {
+        ...mockContext,
+        processRegistry: registry,
+      };
+
+      const spawnResult = await executeSpawn({ program: "sleep", args: ["60"] }, ctxWithRegistry);
+      expect(spawnResult.success).toBe(true);
+      const { pid } = spawnResult.data as { pid: number };
+      pidsToCleanup.push(pid);
+
+      const result = await executeWaitProcess({ pid, timeoutMs: 50 }, ctxWithRegistry);
+      expect(result.success).toBe(false);
+
+      const data = result.data as {
+        pid: number;
+        status: string;
+        exited: boolean;
+        timedOut: boolean;
+        waitedMs: number;
+      };
+      expect(data.pid).toBe(pid);
+      expect(data.status).toBe("running");
+      expect(data.exited).toBe(false);
+      expect(data.timedOut).toBe(true);
+      expect(data.waitedMs).toBeGreaterThanOrEqual(0);
+    });
+
+    it("wait_process should perform immediate liveness check when timeoutMs is zero", async () => {
+      const registry = new SpawnedProcessRegistry();
+      const ctxWithRegistry: ToolContext = {
+        ...mockContext,
+        processRegistry: registry,
+      };
+
+      const spawnResult = await executeSpawn({ program: "sleep", args: ["60"] }, ctxWithRegistry);
+      expect(spawnResult.success).toBe(true);
+      const { pid } = spawnResult.data as { pid: number };
+      pidsToCleanup.push(pid);
+
+      const result = await executeWaitProcess({ pid, timeoutMs: 0 }, ctxWithRegistry);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("Timed out waiting");
+
+      const data = result.data as {
+        pid: number;
+        status: string;
+        exited: boolean;
+        timedOut: boolean;
+        waitedMs: number;
+      };
+      expect(data.pid).toBe(pid);
+      expect(data.status).toBe("running");
+      expect(data.exited).toBe(false);
+      expect(data.timedOut).toBe(true);
+      expect(data.waitedMs).toBeGreaterThanOrEqual(0);
+    });
+
+    it("wait_process should fail with not tracked for unknown pid", async () => {
+      const registry = new SpawnedProcessRegistry();
+      const ctxWithRegistry: ToolContext = {
+        ...mockContext,
+        processRegistry: registry,
+      };
+
+      const result = await executeWaitProcess({ pid: 999_999, timeoutMs: 0 }, ctxWithRegistry);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("not tracked");
+      expect(result.data).toMatchObject({
+        pid: 999_999,
+        exited: false,
+        timedOut: false,
+      });
+    });
+
+    it("interactive PTY process lifecycle should be reflected in list and wait", async () => {
+      const registry = new SpawnedProcessRegistry();
+      const ptySessionStore = new PTYSessionStore();
+      const ctxWithRegistry: ToolContext = {
+        ...mockContext,
+        processRegistry: registry,
+        ptySessionStore,
+      };
+
+      const fakePid = 424242;
+      const fakeSession = {
+        pid: fakePid,
+        isRunning: true,
+        exitCode: undefined as number | undefined,
+        output: "",
+        write: () => undefined,
+        close: () => undefined,
+      };
+      const createPTYSessionSpy = vi
+        .spyOn(ptyModule, "createPTYSession")
+        .mockResolvedValue(fakeSession as unknown as Awaited<ReturnType<typeof ptyModule.createPTYSession>>);
+
+      try {
+        const spawnResult = await executeSpawn(
+          {
+            program: "fake-shell",
+            args: ["-lc", "echo interactive-done"],
+            interactive: true,
+          },
+          ctxWithRegistry,
+        );
+        expect(spawnResult.success).toBe(true);
+        const { pid } = spawnResult.data as { pid: number };
+        expect(pid).toBe(fakePid);
+
+        expect(registry.has(pid)).toBe(true);
+        expect(ptySessionStore.has(pid)).toBe(true);
+
+        setTimeout(() => {
+          fakeSession.isRunning = false;
+          fakeSession.exitCode = 0;
+        }, 20);
+
+        const waitResult = await executeWaitProcess({ pid, timeoutMs: 5000 }, ctxWithRegistry);
+        expect(waitResult.success).toBe(true);
+
+        const waitData = waitResult.data as {
+          pid: number;
+          status: string;
+          exited: boolean;
+          interactive: boolean;
+          timedOut: boolean;
+          waitedMs: number;
+          exitCode: number | null;
+        };
+        expect(waitData.pid).toBe(pid);
+        expect(waitData.status).toBe("exited");
+        expect(waitData.exited).toBe(true);
+        expect(waitData.interactive).toBe(true);
+        expect(waitData.timedOut).toBe(false);
+        expect(waitData.waitedMs).toBeGreaterThanOrEqual(0);
+        expect(waitData.exitCode).toBe(0);
+
+        // The lifecycle monitor runs asynchronously after PTY exit.
+        await new Promise((resolve) => setTimeout(resolve, 120));
+        expect(ptySessionStore.has(pid)).toBe(false);
+
+        const listResult = await executeListProcesses({ includeExited: true }, ctxWithRegistry);
+        expect(listResult.success).toBe(true);
+        const listData = listResult.data as {
+          processes: Array<{ pid: number; status: string; interactive: boolean }>;
+        };
+        const processInfo = listData.processes.find((process) => process.pid === pid);
+        expect(processInfo).toMatchObject({
+          pid,
+          status: "exited",
+          interactive: true,
+        });
+      } finally {
+        createPTYSessionSpy.mockRestore();
+      }
+    }, 15000);
+
+    it("kill should keep tracked process for non-terminating signals", async () => {
+      const registry = new SpawnedProcessRegistry();
+      const ctxWithRegistry: ToolContext = {
+        ...mockContext,
+        processRegistry: registry,
+      };
+
+      const spawnResult = await executeSpawn({ program: "sleep", args: ["60"] }, ctxWithRegistry);
+      expect(spawnResult.success).toBe(true);
+      const { pid } = spawnResult.data as { pid: number };
+      pidsToCleanup.push(pid);
+      expect(registry.has(pid)).toBe(true);
+
+      const killResult = await executeKill({ pid, signal: "SIGCONT" }, ctxWithRegistry);
+      expect(killResult.success).toBe(true);
+      expect(registry.has(pid)).toBe(true);
+
+      const waitResult = await executeWaitProcess({ pid, timeoutMs: 50 }, ctxWithRegistry);
+      expect(waitResult.success).toBe(false);
+      const waitData = waitResult.data as {
+        status: string;
+        exited: boolean;
+        timedOut: boolean;
+        waitedMs: number;
+      };
+      expect(waitData.status).toBe("running");
+      expect(waitData.exited).toBe(false);
+      expect(waitData.timedOut).toBe(true);
+      expect(waitData.waitedMs).toBeGreaterThanOrEqual(0);
+    });
+  });
+});