seahorse-bash-client 1.0.0

package/src/pty-manager.test.ts

@@ -0,0 +1,555 @@
+/**
+ * PTY Manager Unit Tests
+ *
+ * Tests for verifying PTY session management, command execution,
+ * and output buffering functionality.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { PTYManager } from './pty-manager';
+
+describe('PTYManager', () => {
+  let ptyManager: PTYManager;
+
+  beforeEach(() => {
+    ptyManager = new PTYManager({
+      maxOutputLines: 1000,
+      defaultShell: '/bin/bash',
+    });
+  });
+
+  afterEach(async () => {
+    await ptyManager.shutdown();
+  });
+
+  describe('exec', () => {
+    it('should execute a simple command and return output', async () => {
+      const result = await ptyManager.exec({
+        command: 'echo "hello world"',
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('hello world');
+      expect(result.timedOut).toBe(false);
+    });
+
+    it('should capture exit code from failed command', async () => {
+      const result = await ptyManager.exec({
+        command: 'exit 42',
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(42);
+      expect(result.timedOut).toBe(false);
+    });
+
+    it('should timeout long-running commands', async () => {
+      const result = await ptyManager.exec({
+        command: 'sleep 10',
+        timeout: 500,
+      });
+
+      expect(result.exitCode).toBe(-1);
+      expect(result.timedOut).toBe(true);
+    });
+
+    it('should respect working directory', async () => {
+      const result = await ptyManager.exec({
+        command: 'pwd',
+        cwd: '/tmp',
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(0);
+      // PTY may include ANSI codes, so just check contains
+      expect(result.stdout).toContain('/tmp');
+    });
+
+    it('should pass environment variables', async () => {
+      const result = await ptyManager.exec({
+        command: 'echo $MY_VAR',
+        env: { MY_VAR: 'test_value' },
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('test_value');
+    });
+
+    it('should handle commands with special characters', async () => {
+      const result = await ptyManager.exec({
+        command: 'echo "test with \'quotes\' and $dollar"',
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('quotes');
+    });
+
+    it('should handle multi-line output', async () => {
+      const result = await ptyManager.exec({
+        command: 'echo -e "line1\\nline2\\nline3"',
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('line1');
+      expect(result.stdout).toContain('line2');
+      expect(result.stdout).toContain('line3');
+    });
+
+    it('should handle stderr output', async () => {
+      const result = await ptyManager.exec({
+        command: 'echo "error message" >&2',
+        timeout: 5000,
+      });
+
+      // PTY combines stdout and stderr
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('error message');
+    });
+  });
+
+  describe('spawn', () => {
+    it('should create a new PTY session', async () => {
+      const result = await ptyManager.spawn({
+        command: 'echo "spawn test"',
+      });
+
+      expect(result.sessionId).toMatch(/^pty_/);
+      expect(result.pid).toBeGreaterThan(0);
+      expect(result.status).toBe('running');
+    });
+
+    it('should track session in list', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command: 'sleep 1',
+        name: 'test-session',
+      });
+
+      const listResult = ptyManager.list({ status: 'all' });
+      expect(listResult.sessions.length).toBeGreaterThanOrEqual(1);
+
+      const session = listResult.sessions.find(
+        (s) => s.sessionId === spawnResult.sessionId
+      );
+      expect(session).toBeDefined();
+      expect(session?.name).toBe('test-session');
+    });
+
+    it('should capture output to buffer', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command: 'echo "buffered output"',
+      });
+
+      // Wait for output to be captured
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const readResult = ptyManager.read({
+        sessionId: spawnResult.sessionId,
+        limit: 100,
+      });
+
+      expect(readResult.lines.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should respect terminal size', async () => {
+      const result = await ptyManager.spawn({
+        command: 'tput cols && tput lines',
+        cols: 80,
+        rows: 24,
+      });
+
+      expect(result.sessionId).toMatch(/^pty_/);
+      // The command should run in the specified terminal size
+    });
+  });
+
+  describe('write', () => {
+    it('should write data to a running session', async () => {
+      // Start an interactive session
+      const spawnResult = await ptyManager.spawn({
+        // No command - just a shell
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      const writeResult = ptyManager.write({
+        sessionId: spawnResult.sessionId,
+        data: 'echo "written data"\n',
+      });
+
+      expect(writeResult.success).toBe(true);
+      expect(writeResult.bytesWritten).toBeGreaterThan(0);
+    });
+
+    it('should send special keys', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command: 'sleep 30',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Send Ctrl+C
+      const writeResult = ptyManager.write({
+        sessionId: spawnResult.sessionId,
+        specialKey: 'ctrl+c',
+      });
+
+      expect(writeResult.success).toBe(true);
+      expect(writeResult.bytesWritten).toBe(1); // \x03 is 1 byte
+    });
+
+    it('should fail for non-existent session', () => {
+      expect(() =>
+        ptyManager.write({
+          sessionId: 'non_existent',
+          data: 'test',
+        })
+      ).toThrow('Session not found');
+    });
+  });
+
+  describe('read', () => {
+    it('should read output from session buffer', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command: 'for i in 1 2 3 4 5; do echo "line $i"; done',
+      });
+
+      // Wait for output
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      const readResult = ptyManager.read({
+        sessionId: spawnResult.sessionId,
+        limit: 100,
+      });
+
+      expect(readResult.sessionId).toBe(spawnResult.sessionId);
+      expect(readResult.lines.length).toBeGreaterThan(0);
+    });
+
+    it('should support pagination with offset and limit', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command:
+          'for i in $(seq 1 20); do echo "line $i"; done',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      const readResult = ptyManager.read({
+        sessionId: spawnResult.sessionId,
+        offset: 5,
+        limit: 3,
+      });
+
+      expect(readResult.lines.length).toBeLessThanOrEqual(3);
+    });
+
+    it('should support tail mode', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command:
+          'for i in $(seq 1 20); do echo "line $i"; done',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      const readResult = ptyManager.read({
+        sessionId: spawnResult.sessionId,
+        tail: true,
+        limit: 5,
+      });
+
+      expect(readResult.lines.length).toBeLessThanOrEqual(5);
+    });
+
+    it('should support pattern filtering', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command: 'echo "apple"; echo "banana"; echo "apricot"',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      const readResult = ptyManager.read({
+        sessionId: spawnResult.sessionId,
+        pattern: '^a',
+        limit: 100,
+      });
+
+      // Should filter to lines starting with 'a'
+      const matchingLines = readResult.lines.filter((l) =>
+        l.text.toLowerCase().startsWith('a')
+      );
+      expect(matchingLines.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should fail for non-existent session', () => {
+      expect(() =>
+        ptyManager.read({
+          sessionId: 'non_existent',
+        })
+      ).toThrow('Session not found');
+    });
+  });
+
+  describe('list', () => {
+    it('should return empty list when no sessions', () => {
+      const result = ptyManager.list();
+
+      expect(result.sessions).toEqual([]);
+      expect(result.summary.total).toBe(0);
+    });
+
+    it('should filter by status', async () => {
+      // Create a session that will exit
+      await ptyManager.spawn({
+        command: 'echo "quick"',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const runningResult = ptyManager.list({ status: 'running' });
+      const allResult = ptyManager.list({ status: 'all' });
+
+      expect(allResult.sessions.length).toBeGreaterThanOrEqual(
+        runningResult.sessions.length
+      );
+    });
+
+    it('should include recent output when requested', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command: 'echo "output test"',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const result = ptyManager.list({
+        includeOutput: true,
+        outputLines: 5,
+      });
+
+      const session = result.sessions.find(
+        (s) => s.sessionId === spawnResult.sessionId
+      );
+      expect(session?.recentOutput).toBeDefined();
+    });
+  });
+
+  describe('kill', () => {
+    it('should terminate a running session', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command: 'sleep 60',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      const killResult = await ptyManager.kill({
+        sessionId: spawnResult.sessionId,
+      });
+
+      expect(killResult.sessionId).toBe(spawnResult.sessionId);
+      expect(killResult.signal).toBe('SIGTERM');
+    });
+
+    it('should cleanup session when requested', async () => {
+      const spawnResult = await ptyManager.spawn({
+        command: 'sleep 60',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      await ptyManager.kill({
+        sessionId: spawnResult.sessionId,
+        cleanup: true,
+      });
+
+      const listResult = ptyManager.list();
+      const session = listResult.sessions.find(
+        (s) => s.sessionId === spawnResult.sessionId
+      );
+      expect(session).toBeUndefined();
+    });
+
+    it('should fail for non-existent session', async () => {
+      await expect(
+        ptyManager.kill({
+          sessionId: 'non_existent',
+        })
+      ).rejects.toThrow('Session not found');
+    });
+  });
+
+  describe('Interactive PTY Tests', () => {
+    it('should handle interactive shell input/output', async () => {
+      // Start an interactive shell
+      const spawnResult = await ptyManager.spawn({});
+
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      // Write a command
+      ptyManager.write({
+        sessionId: spawnResult.sessionId,
+        data: 'echo "interactive test"\n',
+      });
+
+      // Wait for output
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      const readResult = ptyManager.read({
+        sessionId: spawnResult.sessionId,
+        tail: true,
+        limit: 20,
+      });
+
+      // Should have captured the output
+      const hasOutput = readResult.lines.some((l) =>
+        l.text.includes('interactive test')
+      );
+      expect(hasOutput).toBe(true);
+
+      // Cleanup
+      await ptyManager.kill({
+        sessionId: spawnResult.sessionId,
+        cleanup: true,
+      });
+    });
+
+    it('should handle rapid input/output', async () => {
+      const spawnResult = await ptyManager.spawn({});
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Send multiple commands rapidly
+      for (let i = 0; i < 5; i++) {
+        ptyManager.write({
+          sessionId: spawnResult.sessionId,
+          data: `echo "rapid ${i}"\n`,
+        });
+      }
+
+      // Wait for all outputs
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      const readResult = ptyManager.read({
+        sessionId: spawnResult.sessionId,
+        tail: true,
+        limit: 50,
+      });
+
+      // Should have captured multiple outputs
+      expect(readResult.lines.length).toBeGreaterThan(0);
+
+      await ptyManager.kill({
+        sessionId: spawnResult.sessionId,
+        cleanup: true,
+      });
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty command output', async () => {
+      const result = await ptyManager.exec({
+        command: 'true',
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should handle very long output', async () => {
+      const result = await ptyManager.exec({
+        command: 'for i in $(seq 1 100); do echo "line $i: padding text here"; done',
+        timeout: 10000,
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.length).toBeGreaterThan(1000);
+    });
+
+    it('should handle binary-like output', async () => {
+      const result = await ptyManager.exec({
+        command: 'echo -e "\\x00\\x01\\x02\\x03"',
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should handle ANSI escape sequences', async () => {
+      const result = await ptyManager.exec({
+        command: 'echo -e "\\033[31mRed\\033[0m"',
+        timeout: 5000,
+      });
+
+      expect(result.exitCode).toBe(0);
+      // Output should contain ANSI codes
+      expect(result.stdout).toContain('\x1b[31m');
+    });
+
+    it('should handle concurrent sessions', async () => {
+      const sessions = await Promise.all([
+        ptyManager.spawn({ command: 'sleep 2; echo "session 1"' }),
+        ptyManager.spawn({ command: 'sleep 2; echo "session 2"' }),
+        ptyManager.spawn({ command: 'sleep 2; echo "session 3"' }),
+      ]);
+
+      const listResult = ptyManager.list();
+      expect(listResult.sessions.length).toBeGreaterThanOrEqual(3);
+
+      // Cleanup
+      for (const session of sessions) {
+        await ptyManager.kill({
+          sessionId: session.sessionId,
+          cleanup: true,
+        });
+      }
+    });
+  });
+
+  describe('Event Emission', () => {
+    it('should emit session:exited event', async () => {
+      const exitedPromise = new Promise<void>((resolve) => {
+        ptyManager.on('session:exited', (data) => {
+          expect(data.sessionId).toMatch(/^pty_/);
+          expect(typeof data.exitCode).toBe('number');
+          resolve();
+        });
+      });
+
+      await ptyManager.spawn({
+        command: 'exit 0',
+        notifyOnExit: true,
+      });
+
+      // Wait for exit event (with timeout)
+      await Promise.race([
+        exitedPromise,
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), 3000)
+        ),
+      ]);
+    });
+
+    it('should emit output event', async () => {
+      const outputPromise = new Promise<void>((resolve) => {
+        ptyManager.on('output', (data) => {
+          if (data.data.includes('output event test')) {
+            resolve();
+          }
+        });
+      });
+
+      await ptyManager.spawn({
+        command: 'echo "output event test"',
+      });
+
+      // Wait for output event (with timeout)
+      await Promise.race([
+        outputPromise,
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), 3000)
+        ),
+      ]);
+    });
+  });
+});