npm - @renxqoo/renx-code - Versions diffs - 0.0.8 → 0.0.10 - Mend

@renxqoo/renx-code 0.0.8 → 0.0.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (286) hide show

package/vendor/agent-root/src/agent/tool/__test__/web-fetch.test.ts DELETED Viewed

@@ -1,244 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-import { WebFetchTool } from '../web-fetch';
-// Mock fetch globally
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-describe('WebFetchTool', () => {
-  let tool: WebFetchTool;
-  beforeEach(() => {
-    tool = new WebFetchTool();
-    vi.clearAllMocks();
-  });
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-  describe('SSRF Protection', () => {
-    it('blocks localhost', async () => {
-      await expect(tool.execute({ url: 'http://localhost/secret' })).rejects.toThrow(
-        'Blocked address: localhost'
-      );
-    });
-    it('blocks 127.0.0.1', async () => {
-      await expect(tool.execute({ url: 'http://127.0.0.1/admin' })).rejects.toThrow(
-        'Blocked address: 127.0.0.1'
-      );
-    });
-    it('blocks 0.0.0.0', async () => {
-      await expect(tool.execute({ url: 'http://0.0.0.0/' })).rejects.toThrow(
-        'Blocked address: 0.0.0.0'
-      );
-    });
-    it('blocks 10.x.x.x private IP', async () => {
-      await expect(tool.execute({ url: 'http://10.0.0.1/internal' })).rejects.toThrow(
-        'Blocked address: 10.0.0.1'
-      );
-    });
-    it('blocks 172.16-31.x.x private IP', async () => {
-      await expect(tool.execute({ url: 'http://172.16.0.1/' })).rejects.toThrow(
-        'Blocked address: 172.16.0.1'
-      );
-      await expect(tool.execute({ url: 'http://172.31.255.255/' })).rejects.toThrow(
-        'Blocked address: 172.31.255.255'
-      );
-    });
-    it('blocks 192.168.x.x private IP', async () => {
-      await expect(tool.execute({ url: 'http://192.168.1.1/router' })).rejects.toThrow(
-        'Blocked address: 192.168.1.1'
-      );
-    });
-    it('blocks 169.254.x.x link-local', async () => {
-      await expect(
-        tool.execute({ url: 'http://169.254.169.254/latest/meta-data/' })
-      ).rejects.toThrow('Blocked address: 169.254.169.254');
-    });
-    it('blocks cloud metadata hostnames', async () => {
-      await expect(tool.execute({ url: 'http://metadata.google.internal/' })).rejects.toThrow(
-        'Blocked address: metadata.google.internal'
-      );
-    });
-    it('blocks non-http protocols', async () => {
-      await expect(tool.execute({ url: 'file:///etc/passwd' })).rejects.toThrow(
-        'Unsupported protocol: file:'
-      );
-    });
-    it('allows public URLs', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        headers: new Map([['content-type', 'text/html']]),
-        text: () => Promise.resolve('<html><body>Hello</body></html>'),
-      });
-      const result = await tool.execute({ url: 'https://example.com/' });
-      expect(result.success).toBe(true);
-      expect(mockFetch).toHaveBeenCalledOnce();
-    });
-  });
-  describe('Content Extraction', () => {
-    it('extracts text from HTML', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        headers: new Map([['content-type', 'text/html']]),
-        text: () => Promise.resolve('<html><body><h1>Title</h1><p>Content</p></body></html>'),
-      });
-      const result = await tool.execute({
-        url: 'https://example.com/',
-        extractMode: 'text',
-      });
-      expect(result.success).toBe(true);
-      expect(result.output).toContain('Title');
-      expect(result.output).toContain('Content');
-      expect(result.output).not.toContain('<h1>');
-    });
-    it('returns raw HTML when extractMode is html', async () => {
-      const html = '<html><body><p>Test</p></body></html>';
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        headers: new Map([['content-type', 'text/html']]),
-        text: () => Promise.resolve(html),
-      });
-      const result = await tool.execute({
-        url: 'https://example.com/',
-        extractMode: 'html',
-      });
-      expect(result.success).toBe(true);
-      expect(result.output).toContain('<p>Test</p>');
-    });
-    it('removes script and style tags in text mode', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        headers: new Map([['content-type', 'text/html']]),
-        text: () =>
-          Promise.resolve(
-            '<html><head><script>alert("xss")</script><style>body{color:red}</style></head><body>Safe content</body></html>'
-          ),
-      });
-      const result = await tool.execute({
-        url: 'https://example.com/',
-        extractMode: 'text',
-      });
-      expect(result.success).toBe(true);
-      expect(result.output).toContain('Safe content');
-      expect(result.output).not.toContain('alert');
-      expect(result.output).not.toContain('color:red');
-    });
-  });
-  describe('Error Handling', () => {
-    it('handles HTTP errors', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 404,
-        statusText: 'Not Found',
-      });
-      await expect(tool.execute({ url: 'https://example.com/notfound' })).rejects.toThrow(
-        'HTTP 404: Not Found'
-      );
-    });
-    it('handles network errors', async () => {
-      mockFetch.mockRejectedValueOnce(new Error('Network error'));
-      await expect(tool.execute({ url: 'https://example.com/' })).rejects.toThrow(
-        'Fetch failed: Network error'
-      );
-    });
-    it('handles timeout', async () => {
-      mockFetch.mockImplementationOnce(
-        () =>
-          new Promise((_, reject) => {
-            const error = new Error('Aborted');
-            error.name = 'AbortError';
-            setTimeout(() => reject(error), 10);
-          })
-      );
-      await expect(tool.execute({ url: 'https://example.com/', timeout: 1000 })).rejects.toThrow(
-        'Request timeout'
-      );
-    });
-  });
-  describe('Output Truncation', () => {
-    it('truncates large content', async () => {
-      const largeContent = 'x'.repeat(100000);
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        headers: new Map([['content-type', 'text/plain']]),
-        text: () => Promise.resolve(largeContent),
-      });
-      const result = await tool.execute({
-        url: 'https://example.com/',
-        maxChars: 1000,
-      });
-      expect(result.success).toBe(true);
-      expect(result.metadata?.truncated).toBe(true);
-      expect(result.output?.length ?? 0).toBeLessThan(2000);
-    });
-  });
-  describe('Schema Validation', () => {
-    it('validates URL format', () => {
-      const validation = tool.safeValidateArgs({ url: 'not-a-url' });
-      expect(validation.success).toBe(false);
-    });
-    it('validates extractMode enum', () => {
-      const validation = tool.safeValidateArgs({
-        url: 'https://example.com',
-        extractMode: 'invalid',
-      });
-      expect(validation.success).toBe(false);
-    });
-    it('validates maxChars range', () => {
-      const validation = tool.safeValidateArgs({
-        url: 'https://example.com',
-        maxChars: 50, // below minimum of 100
-      });
-      expect(validation.success).toBe(false);
-    });
-    it('accepts valid arguments', () => {
-      const validation = tool.safeValidateArgs({
-        url: 'https://example.com',
-        extractMode: 'text',
-        maxChars: 5000,
-        timeout: 10000,
-      });
-      expect(validation.success).toBe(true);
-    });
-  });
-});

package/vendor/agent-root/src/agent/tool/__test__/web-search.test.ts DELETED Viewed

@@ -1,290 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-import { WebSearchTool } from '../web-search';
-// Mock fetch globally
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-describe('WebSearchTool', () => {
-  let tool: WebSearchTool;
-  const savedEnv: Record<string, string | undefined> = {};
-  beforeEach(() => {
-    tool = new WebSearchTool();
-    vi.clearAllMocks();
-    // Save original env values
-    savedEnv.TAVILY_API_KEY = process.env.TAVILY_API_KEY;
-    savedEnv.BRAVE_SEARCH_API_KEY = process.env.BRAVE_SEARCH_API_KEY;
-  });
-  afterEach(() => {
-    vi.restoreAllMocks();
-    // Restore original env values
-    if (savedEnv.TAVILY_API_KEY !== undefined) {
-      process.env.TAVILY_API_KEY = savedEnv.TAVILY_API_KEY;
-    } else {
-      delete process.env.TAVILY_API_KEY;
-    }
-    if (savedEnv.BRAVE_SEARCH_API_KEY !== undefined) {
-      process.env.BRAVE_SEARCH_API_KEY = savedEnv.BRAVE_SEARCH_API_KEY;
-    } else {
-      delete process.env.BRAVE_SEARCH_API_KEY;
-    }
-  });
-  function setEnv(tavily?: string, brave?: string) {
-    if (tavily !== undefined) {
-      process.env.TAVILY_API_KEY = tavily;
-    } else {
-      delete process.env.TAVILY_API_KEY;
-    }
-    if (brave !== undefined) {
-      process.env.BRAVE_SEARCH_API_KEY = brave;
-    } else {
-      delete process.env.BRAVE_SEARCH_API_KEY;
-    }
-  }
-  describe('Provider Selection', () => {
-    it('throws when no API key is configured', async () => {
-      setEnv();
-      await expect(tool.execute({ query: 'test' })).rejects.toThrow('No search API key configured');
-    });
-    it('uses tavily when TAVILY_API_KEY is set', async () => {
-      setEnv('test-key');
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            query: 'test',
-            results: [{ title: 'Result', url: 'https://example.com', content: 'Content' }],
-          }),
-      });
-      const result = await tool.execute({ query: 'test' });
-      expect(result.success).toBe(true);
-      expect(result.metadata?.provider).toBe('tavily');
-      expect(mockFetch).toHaveBeenCalledWith(
-        'https://api.tavily.com/search',
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        })
-      );
-    });
-    it('uses brave when BRAVE_SEARCH_API_KEY is set', async () => {
-      setEnv(undefined, 'brave-key');
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            query: { original: 'test' },
-            web: {
-              results: [{ title: 'Result', url: 'https://example.com', description: 'Desc' }],
-            },
-          }),
-      });
-      const result = await tool.execute({ query: 'test' });
-      expect(result.success).toBe(true);
-      expect(result.metadata?.provider).toBe('brave');
-    });
-    it('prefers tavily when both keys are set and provider is auto', async () => {
-      setEnv('tavily-key', 'brave-key');
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            query: 'test',
-            results: [],
-          }),
-      });
-      const result = await tool.execute({ query: 'test', provider: 'auto' });
-      expect(result.success).toBe(true);
-      expect(result.metadata?.provider).toBe('tavily');
-    });
-    it('respects explicit provider choice', async () => {
-      setEnv('tavily-key', 'brave-key');
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            query: { original: 'test' },
-            web: { results: [] },
-          }),
-      });
-      const result = await tool.execute({ query: 'test', provider: 'brave' });
-      expect(result.success).toBe(true);
-      expect(result.metadata?.provider).toBe('brave');
-    });
-    it('throws when explicit provider key is missing', async () => {
-      setEnv(undefined, 'brave-key');
-      await expect(tool.execute({ query: 'test', provider: 'tavily' })).rejects.toThrow(
-        'TAVILY_API_KEY environment variable is not set'
-      );
-    });
-  });
-  describe('Tavily Search', () => {
-    beforeEach(() => {
-      setEnv('test-key');
-    });
-    it('returns formatted results', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            query: 'typescript',
-            results: [
-              {
-                title: 'TypeScript',
-                url: 'https://typescriptlang.org',
-                content: 'TypeScript is a typed superset of JavaScript',
-                score: 0.95,
-              },
-              {
-                title: 'TS Handbook',
-                url: 'https://typescriptlang.org/docs',
-                content: 'The TypeScript Handbook',
-                score: 0.85,
-              },
-            ],
-          }),
-      });
-      const result = await tool.execute({ query: 'typescript', maxResults: 5 });
-      expect(result.success).toBe(true);
-      expect(result.output).toContain('Search: "typescript"');
-      expect(result.output).toContain('Provider: tavily');
-      expect(result.output).toContain('[1] TypeScript');
-      expect(result.output).toContain('[2] TS Handbook');
-      expect(result.metadata?.resultCount).toBe(2);
-    });
-    it('handles empty results', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            query: 'nonexistent',
-            results: [],
-          }),
-      });
-      const result = await tool.execute({ query: 'nonexistent' });
-      expect(result.success).toBe(true);
-      expect(result.metadata?.resultCount).toBe(0);
-    });
-    it('handles API errors', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 429,
-        statusText: 'Too Many Requests',
-      });
-      await expect(tool.execute({ query: 'test' })).rejects.toThrow('Tavily API error: 429');
-    });
-    it('truncates long snippets', async () => {
-      const longContent = 'x'.repeat(500);
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            query: 'test',
-            results: [{ title: 'Test', url: 'https://example.com', content: longContent }],
-          }),
-      });
-      const result = await tool.execute({ query: 'test' });
-      expect(result.success).toBe(true);
-      expect(result.output).toContain('...');
-    });
-  });
-  describe('Brave Search', () => {
-    beforeEach(() => {
-      setEnv(undefined, 'brave-key');
-    });
-    it('returns formatted results', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            query: { original: 'nodejs' },
-            web: {
-              results: [
-                { title: 'Node.js', url: 'https://nodejs.org', description: 'JavaScript runtime' },
-              ],
-            },
-          }),
-      });
-      const result = await tool.execute({ query: 'nodejs' });
-      expect(result.success).toBe(true);
-      expect(result.output).toContain('Provider: brave');
-      expect(result.output).toContain('[1] Node.js');
-    });
-    it('handles API errors', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 401,
-        statusText: 'Unauthorized',
-      });
-      await expect(tool.execute({ query: 'test' })).rejects.toThrow('Brave Search API error: 401');
-    });
-  });
-  describe('Schema Validation', () => {
-    it('validates query is required', () => {
-      const validation = tool.safeValidateArgs({});
-      expect(validation.success).toBe(false);
-    });
-    it('validates query max length', () => {
-      const validation = tool.safeValidateArgs({ query: 'x'.repeat(501) });
-      expect(validation.success).toBe(false);
-    });
-    it('validates maxResults range', () => {
-      const validation = tool.safeValidateArgs({ query: 'test', maxResults: 11 });
-      expect(validation.success).toBe(false);
-    });
-    it('validates provider enum', () => {
-      const validation = tool.safeValidateArgs({ query: 'test', provider: 'google' });
-      expect(validation.success).toBe(false);
-    });
-    it('accepts valid arguments', () => {
-      const validation = tool.safeValidateArgs({
-        query: 'test query',
-        maxResults: 3,
-        provider: 'auto',
-      });
-      expect(validation.success).toBe(true);
-    });
-  });
-});