@librechat/agents 3.4.6 → 3.5.0

package/src/tools/local/__tests__/FileCheckpointer.test.ts

@@ -1,162 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'fs/promises';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { LocalFileCheckpointerImpl } from '../FileCheckpointer';
-import {
-  WorkspaceClientTimeoutError,
-  type WorkspaceFS,
-} from '../workspaceFS';
-
-/**
- * Pins the LocalFileCheckpointer's per-Run snapshot/rewind contract.
- * Critical because checkpoints are what `--rollback` style features
- * (and the local engine's mid-batch undo) actually rely on — a
- * regression here silently makes rewind a no-op or, worse, restores
- * to the wrong byte content.
- */
-
-describe('LocalFileCheckpointerImpl', () => {
-  let dir: string;
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'lc-fcp-'));
-  });
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  it('captures pre-write content and rewind restores it byte-exact', async () => {
-    const file = join(dir, 'a.txt');
-    await writeFile(file, 'original\n');
-    const cp = new LocalFileCheckpointerImpl();
-
-    await cp.captureBeforeWrite(file);
-    await writeFile(file, 'overwritten\n');
-
-    const restored = await cp.rewind();
-    expect(restored).toBe(1);
-    expect(await readFile(file, 'utf8')).toBe('original\n');
-  });
-
-  it('captureBeforeWrite is idempotent — second capture preserves the FIRST snapshot', async () => {
-    const file = join(dir, 'b.txt');
-    await writeFile(file, 'first');
-    const cp = new LocalFileCheckpointerImpl();
-
-    await cp.captureBeforeWrite(file);
-    // Simulate first write happening between captures, then a second
-    // tool wanting to write the same file. The second capture must be
-    // a no-op so rewind restores back to the very first content.
-    await writeFile(file, 'between');
-    await cp.captureBeforeWrite(file);
-    await writeFile(file, 'last');
-
-    await cp.rewind();
-    expect(await readFile(file, 'utf8')).toBe('first');
-  });
-
-  it('captures absent files and rewind deletes any newly-created path', async () => {
-    const file = join(dir, 'newly-created.txt');
-    const cp = new LocalFileCheckpointerImpl();
-
-    await cp.captureBeforeWrite(file); // file does not exist yet
-    await writeFile(file, 'created by some tool');
-
-    const restored = await cp.rewind();
-    expect(restored).toBe(1);
-    await expect(stat(file)).rejects.toThrow();
-  });
-
-  it('rethrows a client-timeout from stat instead of snapshotting as absent', async () => {
-    // A stalled stat() must NOT be recorded as "absent" — that would delete an
-    // existing file on rewind. The timeout has to surface.
-    const fs = {
-      stat: async () => {
-        throw new WorkspaceClientTimeoutError(
-          'cloudflare sandbox listFiles exceeded 6000ms client-side timeout'
-        );
-      },
-    } as unknown as WorkspaceFS;
-    const cp = new LocalFileCheckpointerImpl(32 * 1024 * 1024, fs);
-
-    await expect(cp.captureBeforeWrite('/workspace/a.txt')).rejects.toThrow(
-      /client-side timeout/
-    );
-    // Nothing was snapshotted, so rewind is a no-op (no spurious deletion).
-    expect(await cp.rewind()).toBe(0);
-  });
-
-  it('rewind rethrows a client-timeout from a restore write instead of claiming success', async () => {
-    // A stalled restore write leaves the bad bytes on disk — rewind must surface
-    // the timeout, not silently count the path as restored.
-    const fs = {
-      stat: async () => ({ isFile: () => true, size: 5 }),
-      readFile: async () => Buffer.from('orig\n'),
-      mkdir: async () => undefined,
-      writeFile: async () => {
-        throw new WorkspaceClientTimeoutError(
-          'cloudflare sandbox writeFile exceeded 6000ms client-side timeout'
-        );
-      },
-    } as unknown as WorkspaceFS;
-    const cp = new LocalFileCheckpointerImpl(32 * 1024 * 1024, fs);
-
-    await cp.captureBeforeWrite('/workspace/a.txt'); // snapshots 'present'
-    await expect(cp.rewind()).rejects.toThrow(/client-side timeout/);
-  });
-
-  it('rewinds across multiple files in a single pass', async () => {
-    const a = join(dir, 'multi-a.txt');
-    const b = join(dir, 'multi-b.txt');
-    await writeFile(a, 'A0');
-    await writeFile(b, 'B0');
-    const cp = new LocalFileCheckpointerImpl();
-
-    await cp.captureBeforeWrite(a);
-    await cp.captureBeforeWrite(b);
-    await writeFile(a, 'A1');
-    await writeFile(b, 'B1');
-
-    const restored = await cp.rewind();
-    expect(restored).toBe(2);
-    expect(await readFile(a, 'utf8')).toBe('A0');
-    expect(await readFile(b, 'utf8')).toBe('B0');
-  });
-
-  it('skips snapshotting files larger than maxBytesPerFile but still tracks them', async () => {
-    const file = join(dir, 'big.bin');
-    // Write 1024 bytes, set the cap to 100 — well under file size.
-    await writeFile(file, Buffer.alloc(1024, 0x41));
-    const cp = new LocalFileCheckpointerImpl(100);
-
-    await cp.captureBeforeWrite(file);
-    expect(cp.capturedPaths()).toContain(file);
-
-    // Mutate the file. Rewind reports 0 restored (nothing snapshotted)
-    // but does not throw — best-effort behavior documented in the
-    // class JSDoc.
-    await writeFile(file, 'mutated');
-    const restored = await cp.rewind();
-    expect(restored).toBe(0);
-    // The file is unchanged from the post-mutation state — there was
-    // nothing snapshotted to restore.
-    expect(await readFile(file, 'utf8')).toBe('mutated');
-  });
-
-  it('rewind of a captured file whose parent directory was removed recreates the directory', async () => {
-    const subdir = join(dir, 'nested', 'deep');
-    const file = join(subdir, 'x.txt');
-    await mkdir(subdir, { recursive: true });
-    await writeFile(file, 'kept');
-    const cp = new LocalFileCheckpointerImpl();
-
-    await cp.captureBeforeWrite(file);
-    // Blow away the subdir entirely — simulates a tool that deleted
-    // the parent directory.
-    await rm(join(dir, 'nested'), { recursive: true, force: true });
-
-    const restored = await cp.rewind();
-    expect(restored).toBe(1);
-    expect(await readFile(file, 'utf8')).toBe('kept');
-  });
-});

package/src/tools/local/__tests__/editStrategies.test.ts

@@ -1,134 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import { applyEdit, locateEdit } from '../editStrategies';
-
-/**
- * Focused unit tests for the fuzzy edit-matching chain. The chain is
- * what determines whether `edit_file` succeeds or silently corrupts a
- * file when the model's `oldString` doesn't byte-match the on-disk
- * content (different indentation, trailing whitespace, etc.). Pinning
- * the strategy boundaries here so a regression in any one strategy
- * surfaces fast.
- *
- * Order of strategies (defined in editStrategies.ts):
- *   1. exact
- *   2. line-trimmed
- *   3. whitespace-normalized
- *   4. indentation-flexible
- */
-
-describe('editStrategies › locateEdit', () => {
-  it('returns an exact-strategy match for a literal byte-equal substring', () => {
-    const source = 'one\ntwo\nthree\n';
-    const m = locateEdit(source, 'two');
-    expect(m).not.toBeNull();
-    expect(m?.strategy).toBe('exact');
-    expect(applyEdit(source, m!, '2')).toBe('one\n2\nthree\n');
-  });
-
-  it('matches at the very start of the source', () => {
-    const source = 'first\nsecond\n';
-    const m = locateEdit(source, 'first');
-    expect(m).not.toBeNull();
-    expect(m?.strategy).toBe('exact');
-    expect(m?.start).toBe(0);
-  });
-
-  it('matches at the very end of the source (no trailing newline)', () => {
-    const source = 'a\nb\nlast';
-    const m = locateEdit(source, 'last');
-    expect(m).not.toBeNull();
-    expect(m?.strategy).toBe('exact');
-    expect(applyEdit(source, m!, 'LAST')).toBe('a\nb\nLAST');
-  });
-
-  it('falls back to line-trimmed when the model lost trailing whitespace inside a multi-line needle', () => {
-    // Source has trailing tab on the second line; needle has none.
-    // Multi-line needle so the exact strategy can't match (the source
-    // line literally has the tab). Line-trimmed compares trimEnd vs
-    // trimEnd and lets it through.
-    const source = 'fn foo() {\n  return 42\t\n}\n';
-    const m = locateEdit(source, 'fn foo() {\n  return 42\n}');
-    expect(m).not.toBeNull();
-    expect(['line-trimmed', 'whitespace-normalized']).toContain(m?.strategy);
-  });
-
-  it('falls back to whitespace-normalized when interior whitespace differs', () => {
-    // Source uses tabs, needle uses spaces.
-    const source = 'if\t(x)\t{\n\treturn\ty;\n}';
-    const m = locateEdit(source, 'if (x) {\n  return y;\n}');
-    expect(m).not.toBeNull();
-    expect(['whitespace-normalized', 'line-trimmed', 'exact']).toContain(
-      m?.strategy
-    );
-  });
-
-  it('falls back to indentation-flexible when block leading indent differs', () => {
-    // Source is indented by 4 spaces, needle by 2 — semantically the
-    // same block, lexically different indent.
-    const source = '    function go() {\n        return 1;\n    }\n';
-    const m = locateEdit(source, '  function go() {\n    return 1;\n  }');
-    expect(m).not.toBeNull();
-    // Any of the looser strategies could legitimately win here; what
-    // matters is that the chain finds *a* match instead of giving up.
-    expect(m?.strategy).not.toBe('exact');
-  });
-
-  it('returns null when nothing in the chain matches', () => {
-    const source = 'alpha\nbeta\ngamma\n';
-    const m = locateEdit(source, 'this string is nowhere in the source');
-    expect(m).toBeNull();
-  });
-
-  it('rejects exact-strategy match when oldString appears more than once (ambiguous)', () => {
-    // The exact strategy explicitly returns null on >1 hit so an
-    // ambiguous edit can't silently pick the wrong span. Pinning
-    // because the audit-of-audit (follow-up F2) flagged that this
-    // boundary was claimed in the commit message but not actually
-    // covered by a test.
-    //
-    // (Whether the *looser* strategies — line-trimmed,
-    // whitespace-normalized, indentation-flexible — should also fail
-    // closed on multi-match is a separate design call: today they
-    // reject duplicate matches at their OWN granularity but the
-    // chain may then fall through to a strategy that picks one
-    // unambiguously. Out of scope for this test.)
-    const source = 'foo bar\nfoo bar\nbaz';
-    expect(locateEdit(source, 'foo bar')).toBeNull();
-  });
-
-  it('returns null on empty oldString (no anchor to locate)', () => {
-    const source = 'a\nb\n';
-    const m = locateEdit(source, '');
-    expect(m).toBeNull();
-  });
-
-  it('handles multi-line needles spanning a blank line', () => {
-    const source = 'before\n\nafter\n';
-    const m = locateEdit(source, 'before\n\nafter');
-    expect(m).not.toBeNull();
-    expect(m?.strategy).toBe('exact');
-  });
-
-  it('handles unicode content (emoji, combining characters)', () => {
-    const source = 'header\n  // ✅ done — café\nfooter\n';
-    const m = locateEdit(source, '  // ✅ done — café');
-    expect(m).not.toBeNull();
-    expect(m?.strategy).toBe('exact');
-  });
-});
-
-describe('editStrategies › applyEdit', () => {
-  it('produces the new source by splicing newString into the matched span', () => {
-    const source = 'aaa BAR ccc';
-    const m = locateEdit(source, 'BAR');
-    expect(m).not.toBeNull();
-    expect(applyEdit(source, m!, 'baz')).toBe('aaa baz ccc');
-  });
-
-  it('is a no-op when newString equals the matched span', () => {
-    const source = 'x y z';
-    const m = locateEdit(source, 'y');
-    expect(m).not.toBeNull();
-    expect(applyEdit(source, m!, 'y')).toBe('x y z');
-  });
-});

package/src/tools/search/content.test.ts

@@ -1,173 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable no-console */
-// content.test.ts
-import * as fs from 'fs';
-import { processContent } from './content';
-
-describe('Link Processor', () => {
-  afterAll(() => {
-    if (fs.existsSync('./temp.html')) {
-      fs.unlinkSync('./temp.html');
-    }
-    if (fs.existsSync('./temp.md')) {
-      fs.unlinkSync('./temp.md');
-    }
-  });
-  // Basic functionality tests
-  test('should replace basic links with references', () => {
-    const html = `
-      <p>Test with <a href="https://example.com/link" title="Example">a link</a></p>
-      <p>And an <img src="https://example.com/img.jpg" alt="image"></p>
-      <p>Plus a <video src="https://example.com/video.mp4"></video></p>
-    `;
-
-    const markdown = `
-      Test with [a link](https://example.com/link "Example")
-      And an ![image](https://example.com/img.jpg)
-      Plus a [video](https://example.com/video.mp4)
-    `;
-
-    const result = processContent(html, markdown);
-
-    expect(result.links.length).toBe(1);
-    expect(result.images.length).toBe(1);
-    expect(result.videos.length).toBe(1);
-    expect(result.markdown).toContain('link#1');
-    expect(result.markdown).toContain('image#1');
-    expect(result.markdown).toContain('video#1');
-  });
-
-  // Edge case tests
-  test('should handle links with parentheses and special characters', () => {
-    const html = `
-      <a href="https://example.com/page(1).html" title="Parens">Link with parens</a>
-      <a href="https://example.com/path?query=test&param=value">Link with query</a>
-    `;
-
-    const markdown = `
-      [Link with parens](https://example.com/page(1).html "Parens")
-      [Link with query](https://example.com/path?query=test&param=value)
-    `;
-
-    const result = processContent(html, markdown);
-
-    expect(result.links.length).toBe(2);
-    expect(result.markdown).toContain('link#1');
-    expect(result.markdown).toContain('link#2');
-  });
-
-  // Performance test with large files
-  test('should process large files efficiently', () => {
-    const html = fs.readFileSync('src/tools/search/test.html', 'utf-8');
-    const markdown = fs.readFileSync('src/tools/search/test.md', 'utf-8');
-
-    // const largeHtml = generateLargeHtml(1000); // 1000 links
-    // fs.writeFileSync('./temp.html', largeHtml);
-
-    // const largeMd = generateLargeMarkdown(1000); // 1000 links
-    // fs.writeFileSync('./temp.md', largeMd);
-
-    // const html = fs.readFileSync('./temp.html', 'utf-8');
-    // const markdown = fs.readFileSync('./temp.md', 'utf-8');
-
-    // Measure time taken to process
-    const startTime = process.hrtime();
-    const result = processContent(html, markdown);
-    const elapsed = process.hrtime(startTime);
-    const timeInMs = elapsed[0] * 1000 + elapsed[1] / 1000000;
-
-    console.log(
-      `Processed ${result.links.length} links, ${result.images.length} images, and ${result.videos.length} videos in ${timeInMs.toFixed(2)}ms`
-    );
-
-    // Basic validations for large file processing
-    expect(result.links.length).toBeGreaterThan(0);
-    expect(result.markdown).toContain('link#');
-
-    // Check if all links were replaced (sample check)
-    expect(result.markdown).not.toContain('https://example.com/link');
-  });
-
-  // Memory usage test
-  test('should have reasonable memory usage', () => {
-    const html = fs.readFileSync('src/tools/search/test.html', 'utf-8');
-    const markdown = fs.readFileSync('src/tools/search/test.md', 'utf-8');
-
-    const beforeMem = process.memoryUsage();
-    processContent(html, markdown);
-    const afterMem = process.memoryUsage();
-
-    const heapUsed = (afterMem.heapUsed - beforeMem.heapUsed) / 1024 / 1024; // MB
-
-    console.log(`Memory used: ${heapUsed.toFixed(2)} MB`);
-
-    // This is a loose check - actual thresholds depend on your environment
-    expect(heapUsed).toBeLessThan(100); // Should use less than 100MB additional heap
-  });
-
-  // Real-world file test (if available)
-  test('should process real-world Wikipedia content', () => {
-    // Try to find real-world test files if they exist
-    const wikiHtml = 'src/tools/search/test.html';
-    const wikiMd = 'src/tools/search/test.md';
-
-    if (fs.existsSync(wikiHtml) && fs.existsSync(wikiMd)) {
-      const html = fs.readFileSync(wikiHtml, 'utf-8');
-      const markdown = fs.readFileSync(wikiMd, 'utf-8');
-
-      const result = processContent(html, markdown);
-
-      console.log(
-        `Processed ${result.links.length} Wikipedia links, ${result.images.length} images, and ${result.videos.length} videos`
-      );
-
-      expect(result.links.length).toBeGreaterThan(10); // Wikipedia articles typically have many links
-      expect(result.markdown).not.toMatch(/\]\(https?:\/\/[^\s")]+\)/); // No regular URLs should remain
-    } else {
-      console.log('Wikipedia test files not found, skipping this test');
-    }
-  });
-});
-
-// Helper function to generate large HTML test data
-function generateLargeHtml(linkCount: number): string {
-  let html = '<html><body>';
-
-  for (let i = 1; i <= linkCount; i++) {
-    html += `<p>Paragraph ${i} with <a href="https://example.com/link${i}" title="Link ${i}">link ${i}</a>`;
-
-    if (i % 10 === 0) {
-      html += ` and <img src="https://example.com/image${i / 10}.jpg" alt="Image ${i / 10}">`;
-    }
-
-    if (i % 50 === 0) {
-      html += ` and <video src="https://example.com/video${i / 50}.mp4" title="Video ${i / 50}"></video>`;
-    }
-
-    html += '</p>';
-  }
-
-  html += '</body></html>';
-  return html;
-}
-
-/** Helper function to generate large Markdown test data  */
-function generateLargeMarkdown(linkCount: number): string {
-  let markdown = '# Test Document\n\n';
-
-  for (let i = 1; i <= linkCount; i++) {
-    markdown += `Paragraph ${i} with [link ${i}](https://example.com/link${i} "Link ${i}")`;
-
-    if (i % 10 === 0) {
-      markdown += ` and ![Image ${i / 10}](https://example.com/image${i / 10}.jpg)`;
-    }
-
-    if (i % 50 === 0) {
-      markdown += ` and [Video ${i / 50}](https://example.com/video${i / 50}.mp4 "Video ${i / 50}")`;
-    }
-
-    markdown += '\n\n';
-  }
-
-  return markdown;
-}