feat: add stdinContent parameter to shell commands

This commit adds a new `stdinContent` parameter to the shellStart and shellExecute functions,
which allows passing content directly to shell commands via stdin. This is particularly useful
for GitHub CLI commands that accept stdin input.

Key changes:
- Add stdinContent parameter to shellStart and shellExecute
- Implement cross-platform approach using base64 encoding
- Update GitHub mode instructions to use stdinContent instead of temporary files
- Add tests for the new functionality
- Add example test files demonstrating usage

Closes #301

Author: bhouston

packages/agent/src/core/toolAgent/config.ts

@@ -126,11 +126,10 @@ export function getDefaultSystemPrompt(toolContext: ToolContext): string {
         '',
         'You should use the Github CLI tool, gh, and the git cli tool, git, that you can access via shell commands.',
         '',
-        'When creating GitHub issues, PRs, or comments, via the gh cli tool, use temporary markdown files for the content instead of inline text:',
-        '- Create a temporary markdown file with the content you want to include',
-        '- Use the file with GitHub CLI commands (e.g., `gh issue create --body-file temp.md`)',
-        '- Clean up the temporary file when done',
-        '- This approach preserves formatting, newlines, and special characters correctly',
+        'When creating GitHub issues, PRs, or comments via the gh cli tool, use the shellStart or shellExecute stdinContent parameter for multiline content:',
+        '- Use the stdinContent parameter to pass the content directly to the command',
+        '- For example: `shellStart({ command: "gh issue create --body-stdin", stdinContent: "Issue description here with **markdown** support", description: "Creating a new issue" })`',
+        '- This approach preserves formatting, newlines, and special characters correctly without requiring temporary files',
       ].join('\n')
     : '';
 

packages/agent/src/tools/shell/shellExecute.test.ts

@@ -1,26 +1,133 @@
-import { describe, it, expect } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { ToolContext } from '../../core/types.js';
-import { getMockToolContext } from '../getTools.test.js';
+import { shellExecuteTool } from './shellExecute';
 
-import { shellExecuteTool } from './shellExecute.js';
+// Mock child_process.exec
+vi.mock('child_process', () => {
+  return {
+    exec: vi.fn(),
+  };
+});
+
+// Mock util.promisify to return our mocked exec
+vi.mock('util', () => {
+  return {
+    promisify: vi.fn((_fn) => {
+      return async () => {
+        return { stdout: 'mocked stdout', stderr: 'mocked stderr' };
+      };
+    }),
+  };
+});
+
+describe('shellExecuteTool', () => {
+  const mockLogger = {
+    log: vi.fn(),
+    debug: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+  };
 
-const toolContext: ToolContext = getMockToolContext();
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
 
-describe('shellExecute', () => {
-  it('should execute shell commands', async () => {
-    const { stdout } = await shellExecuteTool.execute(
-      { command: "echo 'test'", description: 'test' },
-      toolContext,
+  it('should execute a shell command without stdinContent', async () => {
+    const result = await shellExecuteTool.execute(
+      {
+        command: 'echo "test"',
+        description: 'Testing command',
+      },
+      {
+        logger: mockLogger as any,
+      },
     );
-    expect(stdout).toContain('test');
+
+    expect(mockLogger.debug).toHaveBeenCalledWith(
+      'Executing shell command with 30000ms timeout: echo "test"',
+    );
+    expect(result).toEqual({
+      stdout: 'mocked stdout',
+      stderr: 'mocked stderr',
+      code: 0,
+      error: '',
+      command: 'echo "test"',
+    });
   });
 
-  it('should handle command errors', async () => {
-    const { error } = await shellExecuteTool.execute(
-      { command: 'nonexistentcommand', description: 'test' },
-      toolContext,
+  it('should execute a shell command with stdinContent', async () => {
+    const result = await shellExecuteTool.execute(
+      {
+        command: 'cat',
+        description: 'Testing with stdin content',
+        stdinContent: 'test content',
+      },
+      {
+        logger: mockLogger as any,
+      },
+    );
+
+    expect(mockLogger.debug).toHaveBeenCalledWith(
+      'Executing shell command with 30000ms timeout: cat',
+    );
+    expect(mockLogger.debug).toHaveBeenCalledWith(
+      'With stdin content of length: 12',
     );
-    expect(error).toContain('Command failed:');
+    expect(result).toEqual({
+      stdout: 'mocked stdout',
+      stderr: 'mocked stderr',
+      code: 0,
+      error: '',
+      command: 'cat',
+    });
   });
-});
+
+  it('should include stdinContent in log parameters', () => {
+    shellExecuteTool.logParameters(
+      {
+        command: 'cat',
+        description: 'Testing log parameters',
+        stdinContent: 'test content',
+      },
+      {
+        logger: mockLogger as any,
+      },
+    );
+
+    expect(mockLogger.log).toHaveBeenCalledWith(
+      'Running "cat", Testing log parameters (with stdin content)',
+    );
+  });
+
+  it('should handle errors during execution', async () => {
+    // Override the promisify mock to throw an error
+    vi.mocked(vi.importActual('util') as any).promisify.mockImplementationOnce(
+      () => {
+        return async () => {
+          throw new Error('Command failed');
+        };
+      },
+    );
+
+    const result = await shellExecuteTool.execute(
+      {
+        command: 'invalid-command',
+        description: 'Testing error handling',
+      },
+      {
+        logger: mockLogger as any,
+      },
+    );
+
+    expect(mockLogger.debug).toHaveBeenCalledWith(
+      'Executing shell command with 30000ms timeout: invalid-command',
+    );
+    expect(result.error).toContain('Command failed');
+    expect(result.code).toBe(-1);
+  });
+});

packages/agent/src/tools/shell/shellExecute.ts

@@ -20,6 +20,12 @@ const parameterSchema = z.object({
     .number()
     .optional()
     .describe('Timeout in milliseconds (optional, default 30000)'),
+  stdinContent: z
+    .string()
+    .optional()
+    .describe(
+      'Content to pipe into the shell command as stdin (useful for passing multiline content to commands)',
+    ),
 });
 
 const returnSchema = z
@@ -53,18 +59,46 @@ export const shellExecuteTool: Tool<Parameters, ReturnType> = {
   returnsJsonSchema: zodToJsonSchema(returnSchema),
 
   execute: async (
-    { command, timeout = 30000 },
+    { command, timeout = 30000, stdinContent },
     { logger },
   ): Promise<ReturnType> => {
     logger.debug(
       `Executing shell command with ${timeout}ms timeout: ${command}`,
     );
+    if (stdinContent) {
+      logger.debug(`With stdin content of length: ${stdinContent.length}`);
+    }
 
     try {
-      const { stdout, stderr } = await execAsync(command, {
-        timeout,
-        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
-      });
+      let stdout, stderr;
+      
+      // If stdinContent is provided, use platform-specific approach to pipe content
+      if (stdinContent && stdinContent.length > 0) {
+        const isWindows = process.platform === 'win32';
+        const encodedContent = Buffer.from(stdinContent).toString('base64');
+        
+        if (isWindows) {
+          // Windows approach using PowerShell
+          const powershellCommand = `[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${encodedContent}')) | ${command}`;
+          ({ stdout, stderr } = await execAsync(`powershell -Command "${powershellCommand}"`, {
+            timeout,
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+          }));
+        } else {
+          // POSIX approach (Linux/macOS)
+          const bashCommand = `echo "${encodedContent}" | base64 -d | ${command}`;
+          ({ stdout, stderr } = await execAsync(bashCommand, {
+            timeout,
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+          }));
+        }
+      } else {
+        // No stdin content, use normal approach
+        ({ stdout, stderr } = await execAsync(command, {
+          timeout,
+          maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+        }));
+      }
 
       logger.debug('Command executed successfully');
       logger.debug(`stdout: ${stdout.trim()}`);
@@ -109,7 +143,7 @@ export const shellExecuteTool: Tool<Parameters, ReturnType> = {
     }
   },
   logParameters: (input, { logger }) => {
-    logger.log(`Running "${input.command}", ${input.description}`);
+    logger.log(`Running "${input.command}", ${input.description}${input.stdinContent ? ' (with stdin content)' : ''}`);
   },
   logReturns: () => {},
 };