@aria-cli/tools 1.0.9 → 1.0.11

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

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