@ai-devkit/agent-manager 0.22.1 → 0.25.0

package/src/__tests__/terminal/TtyWriter.test.ts

@@ -201,6 +201,96 @@ describe('TtyWriter', () => {
         });
     });
 
+    describe('WezTerm', () => {
+        const location: TerminalLocation = {
+            type: TerminalType.WEZTERM,
+            identifier: '7',
+            tty: '/dev/ttys030',
+        };
+
+        it('sends the message via stdin and Enter as a separate send-text call', async () => {
+            mockExecFileSuccess();
+
+            await TtyWriter.send(location, 'continue');
+
+            // Step 1: message body via stdin, not argv, so prompt contents are
+            // not exposed through process listings.
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'wezterm',
+                ['cli', 'send-text', '--pane-id', '7'],
+                expect.any(Function),
+            );
+            expect(mockedExecFile.mock.results[0]?.value.stdin.end)
+                .toHaveBeenCalledWith('continue');
+            // Step 2: Enter as a single carriage return (0x0d) with --no-paste,
+            // so the CR is delivered literally (not wrapped in paste brackets).
+            // execFile passes the actual CR byte (JS '\x0d'); the equivalent
+            // shell command is:
+            //   wezterm cli send-text --pane-id <id> --no-paste $'\x0d'
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'wezterm',
+                ['cli', 'send-text', '--pane-id', '7', '--no-paste', '\x0d'],
+                expect.any(Function),
+            );
+            expect(mockedExecFile).toHaveBeenCalledTimes(2);
+        });
+
+        it('passes the Enter byte as the carriage return (0x0d), not newline', async () => {
+            mockExecFileSuccess();
+
+            await TtyWriter.send(location, 'continue');
+
+            // The Enter call is the second invocation; its last argv element is
+            // a single byte equal to char code 13 (0x0d).
+            const enterCall = mockedExecFile.mock.calls[1];
+            const enterArgs = enterCall[1] as string[];
+            const enterByte = enterArgs[enterArgs.length - 1];
+            expect(enterByte).toHaveLength(1);
+            expect(enterByte.charCodeAt(0)).toBe(0x0d);
+            expect(enterArgs).toContain('--no-paste');
+        });
+
+        it('keeps the whole message out of argv and writes it verbatim to stdin', async () => {
+            mockExecFileSuccess();
+            const hostile = 'echo pwned; $(rm -rf /) `whoami` | cat\nline2';
+
+            await TtyWriter.send(location, hostile);
+
+            // The message is written verbatim to stdin, not built into a shell
+            // string or exposed as a process argument.
+            const textCall = mockedExecFile.mock.calls[0];
+            const textArgs = textCall[1] as string[];
+            expect(textArgs).toEqual(
+                ['cli', 'send-text', '--pane-id', '7'],
+            );
+            expect(textCall[2]).toBeTypeOf('function');
+            expect(mockedExecFile.mock.results[0]?.value.stdin.end)
+                .toHaveBeenCalledWith(hostile);
+        });
+
+        it('uses the pane id from location.identifier', async () => {
+            mockExecFileSuccess();
+            const pane42 = { ...location, identifier: '42' };
+
+            await TtyWriter.send(pane42, 'hi');
+
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'wezterm',
+                ['cli', 'send-text', '--pane-id', '42'],
+                expect.any(Function),
+            );
+            expect(mockedExecFile.mock.results[0]?.value.stdin.end)
+                .toHaveBeenCalledWith('hi');
+        });
+
+        it('throws when the text send fails', async () => {
+            mockExecFileError('wezterm send-text failed');
+
+            await expect(TtyWriter.send(location, 'hello'))
+                .rejects.toThrow('wezterm send-text failed');
+        });
+    });
+
     describe('unsupported terminal', () => {
         it('throws for unknown terminal type', async () => {
             const location: TerminalLocation = {
@@ -213,4 +303,148 @@ describe('TtyWriter', () => {
                 .rejects.toThrow('Cannot send input: unsupported terminal type');
         });
     });
+
+    describe('sendKey — tmux', () => {
+        const location: TerminalLocation = {
+            type: TerminalType.TMUX,
+            identifier: 'main:0.1',
+            tty: '/dev/ttys030',
+        };
+
+        it('sends key via tmux send-keys directly (no paste buffer, no auto-Enter)', async () => {
+            mockExecFileSuccess();
+
+            await TtyWriter.sendKey(location, '1');
+
+            expect(mockedExecFile).toHaveBeenCalledTimes(1);
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'tmux',
+                ['send-keys', '-t', 'main:0.1', '1'],
+                expect.any(Function),
+            );
+        });
+
+        it('passes through named keys like Enter', async () => {
+            mockExecFileSuccess();
+            await TtyWriter.sendKey(location, 'Enter');
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'tmux',
+                ['send-keys', '-t', 'main:0.1', 'Enter'],
+                expect.any(Function),
+            );
+        });
+
+        it('translates Esc byte (\\x1b) to the named "Escape" key', async () => {
+            mockExecFileSuccess();
+            await TtyWriter.sendKey(location, '\x1b');
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'tmux',
+                ['send-keys', '-t', 'main:0.1', 'Escape'],
+                expect.any(Function),
+            );
+        });
+    });
+
+    describe('sendKey — WezTerm', () => {
+        const location: TerminalLocation = {
+            type: TerminalType.WEZTERM,
+            identifier: '7',
+            tty: '/dev/ttys030',
+        };
+
+        it('uses wezterm cli send-text --no-paste to deliver a raw key', async () => {
+            mockExecFileSuccess();
+
+            await TtyWriter.sendKey(location, '1');
+
+            expect(mockedExecFile).toHaveBeenCalledTimes(1);
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'wezterm',
+                ['cli', 'send-text', '--pane-id', '7', '--no-paste', '1'],
+                expect.any(Function),
+            );
+        });
+    });
+
+    describe('sendKey — iTerm2', () => {
+        const location: TerminalLocation = {
+            type: TerminalType.ITERM2,
+            identifier: '/dev/ttys030',
+            tty: '/dev/ttys030',
+        };
+
+        it('uses System Events keystroke after activating the iTerm2 session', async () => {
+            mockExecFileSuccess('ok');
+
+            await TtyWriter.sendKey(location, '2');
+
+            const args = (mockedExecFile.mock.calls[0] as unknown[])[1] as string[];
+            const script = args[1];
+            expect(script).toContain('tell application "iTerm"');
+            expect(script).toContain('tell application "System Events" to keystroke "2"');
+            expect(mockedExecFile).toHaveBeenCalledTimes(1);
+        });
+
+        it('translates Esc byte (\\x1b) to AppleScript `key code 53`', async () => {
+            mockExecFileSuccess('ok');
+            await TtyWriter.sendKey(location, '\x1b');
+            const args = (mockedExecFile.mock.calls[0] as unknown[])[1] as string[];
+            const script = args[1];
+            expect(script).toContain('tell application "System Events" to key code 53');
+            expect(script).not.toContain('keystroke');
+        });
+
+        it('throws when session not found', async () => {
+            mockExecFileSuccess('not_found');
+            await expect(TtyWriter.sendKey(location, '1'))
+                .rejects.toThrow('iTerm2 session not found');
+        });
+    });
+
+    describe('sendKey — Terminal.app', () => {
+        const location: TerminalLocation = {
+            type: TerminalType.TERMINAL_APP,
+            identifier: '/dev/ttys030',
+            tty: '/dev/ttys030',
+        };
+
+        it('uses System Events keystroke after selecting the Terminal.app tab', async () => {
+            mockExecFileSuccess('ok');
+
+            await TtyWriter.sendKey(location, '3');
+
+            const args = (mockedExecFile.mock.calls[0] as unknown[])[1] as string[];
+            const script = args[1];
+            expect(script).toContain('tell application "Terminal"');
+            expect(script).toContain('tell application "System Events" to keystroke "3"');
+            expect(mockedExecFile).toHaveBeenCalledTimes(1);
+        });
+
+        it('translates Esc byte (\\x1b) to AppleScript `key code 53`', async () => {
+            mockExecFileSuccess('ok');
+            await TtyWriter.sendKey(location, '\x1b');
+            const args = (mockedExecFile.mock.calls[0] as unknown[])[1] as string[];
+            const script = args[1];
+            expect(script).toContain('tell application "System Events" to key code 53');
+            expect(script).not.toContain('keystroke');
+        });
+
+        it('throws when tab not found', async () => {
+            mockExecFileSuccess('not_found');
+            await expect(TtyWriter.sendKey(location, '1'))
+                .rejects.toThrow('Terminal.app tab not found');
+        });
+    });
+
+    describe('sendKey — unsupported terminal', () => {
+        it('throws for unknown terminal type', async () => {
+            const location: TerminalLocation = {
+                type: TerminalType.UNKNOWN,
+                identifier: '',
+                tty: '/dev/ttys030',
+            };
+            await expect(TtyWriter.sendKey(location, '1'))
+                .rejects.toThrow('Cannot send key: unsupported terminal type');
+        });
+    });
 });

package/src/__tests__/utils/agent-requests.test.ts

@@ -0,0 +1,74 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { getAgentRequestPath, readLatestAgentRequest, writeAgentRequest, type AgentRequest } from '../../utils/agent-requests.js';
+
+describe('agent-requests', () => {
+    let homeDir: string;
+
+    beforeEach(() => {
+        homeDir = mkdtempSync(join(tmpdir(), 'agent-requests-test-'));
+    });
+
+    afterEach(() => {
+        rmSync(homeDir, { recursive: true, force: true });
+    });
+
+    describe('getAgentRequestPath', () => {
+        it('returns ~/.ai-devkit/agent-requests/<sessionId>.json', () => {
+            expect(getAgentRequestPath(homeDir, 'abc-123')).toBe(
+                join(homeDir, '.ai-devkit', 'agent-requests', 'abc-123.json'),
+            );
+        });
+    });
+
+    describe('writeAgentRequest', () => {
+        it('creates the directory and file on first write', () => {
+            const entry: AgentRequest = {
+                sessionId: 'sess-1',
+                toolName: 'Bash',
+                toolInput: { command: 'ls /tmp' },
+                timestamp: '2026-06-29T00:00:00.000Z',
+            };
+            writeAgentRequest(homeDir, entry);
+
+            expect(readLatestAgentRequest(homeDir, 'sess-1')).toEqual(entry);
+        });
+
+        it('overwrites an existing entry on subsequent writes', () => {
+            const first: AgentRequest = { sessionId: 'sess-2', toolName: 'Bash', toolInput: { command: 'echo first' }, timestamp: '2026-06-29T00:00:01.000Z' };
+            const second: AgentRequest = { sessionId: 'sess-2', toolName: 'Bash', toolInput: { command: 'echo second' }, timestamp: '2026-06-29T00:00:02.000Z' };
+
+            writeAgentRequest(homeDir, first);
+            writeAgentRequest(homeDir, second);
+
+            expect(readLatestAgentRequest(homeDir, 'sess-2')).toEqual(second);
+        });
+    });
+
+    describe('readLatestAgentRequest', () => {
+        it('returns null when no file exists for the session', () => {
+            expect(readLatestAgentRequest(homeDir, 'no-such-session')).toBeNull();
+        });
+
+        it('returns null when the file contains malformed JSON', () => {
+            const entry: AgentRequest = { sessionId: 'bad', toolName: 'Bash', toolInput: {}, timestamp: '2026-06-29T00:00:00.000Z' };
+            writeAgentRequest(homeDir, entry);
+            writeFileSync(getAgentRequestPath(homeDir, 'bad'), 'NOT JSON{{{', 'utf-8');
+
+            expect(readLatestAgentRequest(homeDir, 'bad')).toBeNull();
+        });
+
+        it('returns the stored entry when the file is valid', () => {
+            const entry: AgentRequest = {
+                sessionId: 'good',
+                toolName: 'AskUserQuestion',
+                toolInput: { question: 'Which option?', options: ['A', 'B'] },
+                timestamp: '2026-06-29T12:00:00.000Z',
+            };
+            writeAgentRequest(homeDir, entry);
+
+            expect(readLatestAgentRequest(homeDir, 'good')).toEqual(entry);
+        });
+    });
+});

package/src/__tests__/utils/agents.test.ts

@@ -14,4 +14,11 @@ describe('AGENTS', () => {
         expect(AGENTS.pi.matches('/usr/local/bin/pi --model x')).toBe(true);
         expect(AGENTS.pi.matches('node /repo/feature-pi-adapter/script.js')).toBe(false);
     });
+
+    it('includes Grok as a startable agent', () => {
+        expect(AGENTS.grok_cli.command).toBe('grok');
+        expect(AGENTS.grok_cli.matches('grok')).toBe(true);
+        expect(AGENTS.grok_cli.matches('/Users/dev/.grok/bin/grok --always-approve')).toBe(true);
+        expect(AGENTS.grok_cli.matches('node /repo/feature-grok-cli/script.js')).toBe(false);
+    });
 });

package/src/adapters/AgentAdapter.ts

@@ -8,7 +8,7 @@
 /**
  * Type of AI agent
  */
-export type AgentType = 'claude' | 'gemini_cli' | 'codex' | 'opencode' | 'copilot' | 'pi' | 'other';
+export type AgentType = 'claude' | 'gemini_cli' | 'grok_cli' | 'codex' | 'opencode' | 'copilot' | 'pi' | 'other';
 
 /**
  * Current status of an agent