keystone-cli 1.0.3 → 1.1.0

package/src/runner/shell-executor.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'bun:test';
 import type { ExpressionContext } from '../expression/evaluator';
 import type { ShellStep } from '../parser/schema';
-import { escapeShellArg, executeShell } from './shell-executor';
+import { escapeShellArg, executeShell } from './executors/shell-executor.ts';
 
 describe('shell-executor', () => {
   describe('escapeShellArg', () => {
@@ -27,6 +27,7 @@ describe('shell-executor', () => {
         type: 'shell',
         needs: [],
         run: 'echo "hello world"',
+        allowInsecure: true,
       };
 
       const result = await executeShell(step, context);
@@ -40,6 +41,7 @@ describe('shell-executor', () => {
         type: 'shell',
         needs: [],
         run: 'echo "${{ inputs.name }}"',
+        allowInsecure: true,
       };
       const customContext: ExpressionContext = {
         ...context,
@@ -56,6 +58,7 @@ describe('shell-executor', () => {
         type: 'shell',
         needs: [],
         run: 'echo $TEST_VAR',
+        allowInsecure: true,
         env: {
           TEST_VAR: 'env-value',
         },
@@ -72,6 +75,7 @@ describe('shell-executor', () => {
         needs: [],
         run: 'pwd',
         dir: '/tmp',
+        allowOutsideCwd: true,
       };
 
       const result = await executeShell(step, context);
@@ -84,6 +88,7 @@ describe('shell-executor', () => {
         type: 'shell',
         needs: [],
         run: 'echo "error" >&2',
+        allowInsecure: true,
       };
 
       const result = await executeShell(step, context);
@@ -96,6 +101,7 @@ describe('shell-executor', () => {
         type: 'shell',
         needs: [],
         run: 'exit 1',
+        allowInsecure: true,
       };
 
       const result = await executeShell(step, context);
@@ -113,12 +119,13 @@ describe('shell-executor', () => {
       await expect(executeShell(step, context)).rejects.toThrow(/Security Error/);
     });
 
-    it('should allow legitimate shell variable expansion like ${HOME}', async () => {
+    it('should allow shell variable expansion like ${HOME} when allowInsecure is true', async () => {
       const step: ShellStep = {
         id: 'test',
         type: 'shell',
         needs: [],
         run: 'echo ${HOME}',
+        allowInsecure: true,
       };
 
       // Should NOT throw - ${HOME} is legitimate
@@ -127,7 +134,7 @@ describe('shell-executor', () => {
       expect(result.stdout.trim()).toBe(Bun.env.HOME || '');
     });
 
-    it('should still block dangerous parameter expansion like ${IFS}', async () => {
+    it('should block parameter expansion like ${IFS} by default', async () => {
       const step: ShellStep = {
         id: 'test',
         type: 'shell',
@@ -137,12 +144,29 @@ describe('shell-executor', () => {
 
       await expect(executeShell(step, context)).rejects.toThrow(/Security Error/);
     });
-    it('should allow flow control with semicolons', async () => {
+
+    it('should allow braces and quotes for JSON usage with allowInsecure', async () => {
+      // {} and quotes now require allowInsecure due to strict whitelist
+      const step: ShellStep = {
+        id: 'test',
+        type: 'shell',
+        needs: [],
+        run: 'echo \'{"values": [1, 2, 3]}\'',
+        allowInsecure: true,
+      };
+
+      const result = await executeShell(step, context);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.trim()).toBe('{"values": [1, 2, 3]}');
+    });
+
+    it('should allow flow control with semicolons when allowInsecure is true', async () => {
       const step: ShellStep = {
         id: 'test',
         type: 'shell',
         needs: [],
         run: 'if [ "1" = "1" ]; then echo "match"; fi',
+        allowInsecure: true,
       };
 
       const result = await executeShell(step, context);

package/src/runner/standard-tools-ast.test.ts

@@ -0,0 +1,196 @@
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as vm from 'node:vm';
+import { STANDARD_TOOLS, validateStandardToolSecurity } from './standard-tools';
+
+describe('AST-Grep Tools', () => {
+  let tempDir: string;
+  let testFile: string;
+
+  beforeAll(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ast-grep-test-'));
+    testFile = path.join(tempDir, 'test.js');
+    fs.writeFileSync(
+      testFile,
+      `function hello() {
+  console.log("world");
+  console.log("hello");
+}
+`
+    );
+  });
+
+  afterAll(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Tool Definitions', () => {
+    it('should have ast_grep_search tool', () => {
+      const tool = STANDARD_TOOLS.find((t) => t.name === 'ast_grep_search');
+      expect(tool).toBeDefined();
+      expect(tool?.execution?.type).toBe('script');
+      expect(tool?.parameters?.required).toContain('pattern');
+      expect(tool?.parameters?.required).toContain('paths');
+    });
+
+    it('should have ast_grep_replace tool', () => {
+      const tool = STANDARD_TOOLS.find((t) => t.name === 'ast_grep_replace');
+      expect(tool).toBeDefined();
+      expect(tool?.execution?.type).toBe('script');
+      expect(tool?.parameters?.required).toContain('pattern');
+      expect(tool?.parameters?.required).toContain('rewrite');
+      expect(tool?.parameters?.required).toContain('paths');
+    });
+
+    it('should have append_file tool', () => {
+      const tool = STANDARD_TOOLS.find((t) => t.name === 'append_file');
+      expect(tool).toBeDefined();
+      expect(tool?.execution?.type).toBe('file');
+      expect(tool?.execution?.op).toBe('append');
+    });
+  });
+
+  describe('Security Validation', () => {
+    const cwd = process.cwd();
+
+    it('should allow AST tools for paths within CWD', () => {
+      expect(() => {
+        validateStandardToolSecurity(
+          'ast_grep_search',
+          { pattern: 'console.log($A)', paths: ['src/test.ts'] },
+          { allowOutsideCwd: false }
+        );
+      }).not.toThrow();
+    });
+
+    it('should block AST tools for paths outside CWD', () => {
+      expect(() => {
+        validateStandardToolSecurity(
+          'ast_grep_search',
+          { pattern: 'console.log($A)', paths: ['/etc/passwd'] },
+          { allowOutsideCwd: false }
+        );
+      }).toThrow(/Access denied/);
+    });
+
+    it('should allow AST tools for paths outside CWD when allowOutsideCwd is true', () => {
+      expect(() => {
+        validateStandardToolSecurity(
+          'ast_grep_replace',
+          { pattern: 'foo', rewrite: 'bar', paths: ['/tmp/test.js'] },
+          { allowOutsideCwd: true }
+        );
+      }).not.toThrow();
+    });
+
+    it('should validate all paths in the array', () => {
+      expect(() => {
+        validateStandardToolSecurity(
+          'ast_grep_search',
+          { pattern: 'test', paths: ['src/ok.ts', '../../outside.ts'] },
+          { allowOutsideCwd: false }
+        );
+      }).toThrow(/Access denied/);
+    });
+
+    it('should allow append_file within CWD', () => {
+      expect(() => {
+        validateStandardToolSecurity(
+          'append_file',
+          { path: 'test.log', content: 'test' },
+          { allowOutsideCwd: false }
+        );
+      }).not.toThrow();
+    });
+  });
+
+  describe('AST-Grep Search Execution', () => {
+    it('should compile ast_grep_search script without errors', () => {
+      const tool = STANDARD_TOOLS.find((t) => t.name === 'ast_grep_search');
+      expect(tool).toBeDefined();
+
+      const script = tool?.execution?.run as string;
+      const sandbox = {
+        args: { pattern: 'console.log($A)', language: 'javascript', paths: [] },
+        require: (mod: string) => {
+          if (mod === 'node:fs' || mod === 'fs') {
+            return {
+              existsSync: () => false,
+              readFileSync: () => '',
+            };
+          }
+          if (mod === 'node:path' || mod === 'path') {
+            return { join: (...args: string[]) => args.join('/') };
+          }
+          if (mod === '@ast-grep/napi') {
+            return {
+              Lang: {
+                JavaScript: 'javascript',
+                TypeScript: 'typescript',
+              },
+              parse: () => ({
+                root: () => ({
+                  findAll: () => [],
+                }),
+              }),
+            };
+          }
+          return {};
+        },
+      };
+
+      expect(() => {
+        vm.runInNewContext(script, sandbox);
+      }).not.toThrow();
+    });
+  });
+
+  describe('AST-Grep Replace Execution', () => {
+    it('should compile ast_grep_replace script without errors', () => {
+      const tool = STANDARD_TOOLS.find((t) => t.name === 'ast_grep_replace');
+      expect(tool).toBeDefined();
+
+      const script = tool?.execution?.run as string;
+      const sandbox = {
+        args: {
+          pattern: 'console.log($A)',
+          rewrite: 'logger.info($A)',
+          language: 'javascript',
+          paths: [],
+        },
+        require: (mod: string) => {
+          if (mod === 'node:fs' || mod === 'fs') {
+            return {
+              existsSync: () => false,
+              readFileSync: () => '',
+              writeFileSync: () => {},
+            };
+          }
+          if (mod === 'node:path' || mod === 'path') {
+            return { join: (...args: string[]) => args.join('/') };
+          }
+          if (mod === '@ast-grep/napi') {
+            return {
+              Lang: {
+                JavaScript: 'javascript',
+                TypeScript: 'typescript',
+              },
+              parse: () => ({
+                root: () => ({
+                  replace: () => '',
+                }),
+              }),
+            };
+          }
+          return {};
+        },
+      };
+
+      expect(() => {
+        vm.runInNewContext(script, sandbox);
+      }).not.toThrow();
+    });
+  });
+});

package/src/runner/standard-tools-execution.test.ts

@@ -19,6 +19,7 @@ describe('Standard Tools Execution Verification', () => {
               readdirSync: () => [],
               statSync: () => ({ size: 0 }),
               readFileSync: () => '',
+              writeFileSync: () => {},
             };
           }
           if (mod === 'node:path' || mod === 'path') {
@@ -27,6 +28,32 @@ describe('Standard Tools Execution Verification', () => {
           if (mod === 'glob') {
             return { globSync: () => [] };
           }
+          if (mod === '@ast-grep/napi') {
+            return {
+              Lang: {
+                JavaScript: 'javascript',
+                TypeScript: 'typescript',
+                Tsx: 'tsx',
+                Python: 'python',
+                Rust: 'rust',
+                Go: 'go',
+                C: 'c',
+                Cpp: 'cpp',
+                Java: 'java',
+                Kotlin: 'kotlin',
+                Swift: 'swift',
+                Html: 'html',
+                Css: 'css',
+                Json: 'json',
+              },
+              parse: () => ({
+                root: () => ({
+                  findAll: () => [],
+                  replace: () => '',
+                }),
+              }),
+            };
+          }
           return {};
         },
       };

package/src/runner/standard-tools-integration.test.ts

@@ -3,8 +3,8 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import type { ExpressionContext } from '../expression/evaluator';
 import type { LlmStep, Step } from '../parser/schema';
+import { executeLlmStep } from './executors/llm-executor.ts';
 import type { LLMAdapter } from './llm-adapter';
-import { executeLlmStep } from './llm-executor';
 import type { StepResult } from './step-executor';
 
 describe('Standard Tools Integration', () => {
@@ -42,8 +42,7 @@ System prompt`,
   });
 
   it('should inject standard tools when useStandardTools is true', async () => {
-    // biome-ignore lint/suspicious/noExplicitAny: mock
-    let capturedTools: any[] = [];
+    let capturedTools: unknown[] = [];
 
     const chatMock = mock(async (messages, options) => {
       capturedTools = options.tools || [];
@@ -63,8 +62,7 @@ System prompt`,
           ],
         },
         usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 },
-        // biome-ignore lint/suspicious/noExplicitAny: mock
-      } as any;
+      };
     }) as unknown as LLMAdapter['chat'];
     const getAdapter = createMockGetAdapter(chatMock);
 
@@ -133,8 +131,7 @@ System prompt`,
         return {
           message: { role: 'assistant', content: 'stop' },
           usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
-          // biome-ignore lint/suspicious/noExplicitAny: mock
-        } as any;
+        };
       }
       return {
         message: {
@@ -143,12 +140,11 @@ System prompt`,
             {
               id: 'c2',
               type: 'function',
-              function: { name: 'run_command', arguments: '{"command":"rm -rf /"}' },
+              function: { name: 'run_command', arguments: '{"command":"echo $HOME"}' },
             },
           ],
         },
-        // biome-ignore lint/suspicious/noExplicitAny: mock
-      } as any;
+      };
     }) as unknown as LLMAdapter['chat'];
     const getAdapter = createMockGetAdapter(chatMock);