onbuzz 3.4.0 → 3.6.2

package/src/services/__tests__/errorHandler.test.js

@@ -0,0 +1,314 @@
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock constants before importing the module under test
+const ERROR_TYPES = {
+  FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+  PERMISSION_DENIED: 'PERMISSION_DENIED',
+  OPERATION_TIMEOUT: 'OPERATION_TIMEOUT',
+  RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
+  AUTHENTICATION_FAILED: 'AUTHENTICATION_FAILED',
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+  VALIDATION_ERROR: 'VALIDATION_ERROR',
+  CONFIGURATION_ERROR: 'CONFIGURATION_ERROR'
+};
+
+const HTTP_STATUS = {
+  OK: 200,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+};
+
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  ERROR_TYPES,
+  HTTP_STATUS,
+  AGENT_STATUS: {}
+}));
+
+const { ErrorHandler } = await import('../errorHandler.js');
+
+describe('ErrorHandler', () => {
+  let handler;
+  let logger;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    logger = createMockLogger();
+    handler = new ErrorHandler(createMockConfig(), logger);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  // --- classifyError ---
+
+  test('classifyError returns FILE_NOT_FOUND for ENOENT errors', () => {
+    const error = new Error('File missing');
+    error.code = 'ENOENT';
+    const info = handler.classifyError(error);
+    expect(info.type).toBe(ERROR_TYPES.FILE_NOT_FOUND);
+    expect(info.message).toBe('File missing');
+    expect(info.id).toMatch(/^err_/);
+    expect(info.timestamp).toBeDefined();
+  });
+
+  test('classifyError returns PERMISSION_DENIED for EACCES errors', () => {
+    const error = new Error('Access denied');
+    error.code = 'EACCES';
+    const info = handler.classifyError(error);
+    expect(info.type).toBe(ERROR_TYPES.PERMISSION_DENIED);
+  });
+
+  test('classifyError returns AUTHENTICATION_FAILED for 401 status', () => {
+    const error = new Error('Unauthorized');
+    error.status = HTTP_STATUS.UNAUTHORIZED;
+    const info = handler.classifyError(error);
+    expect(info.type).toBe(ERROR_TYPES.AUTHENTICATION_FAILED);
+  });
+
+  test('classifyError returns RATE_LIMIT_EXCEEDED for 429 status', () => {
+    const error = new Error('Rate limit');
+    error.status = HTTP_STATUS.TOO_MANY_REQUESTS;
+    const info = handler.classifyError(error);
+    expect(info.type).toBe(ERROR_TYPES.RATE_LIMIT_EXCEEDED);
+  });
+
+  test('classifyError returns OPERATION_TIMEOUT for timeout message', () => {
+    const error = new Error('Request timed out');
+    const info = handler.classifyError(error);
+    expect(info.type).toBe(ERROR_TYPES.OPERATION_TIMEOUT);
+  });
+
+  test('classifyError returns VALIDATION_ERROR for validation message', () => {
+    const error = new Error('Input validation failed');
+    const info = handler.classifyError(error);
+    expect(info.type).toBe(ERROR_TYPES.VALIDATION_ERROR);
+  });
+
+  test('classifyError returns CONFIGURATION_ERROR for config message', () => {
+    const error = new Error('Bad configuration');
+    const info = handler.classifyError(error);
+    expect(info.type).toBe(ERROR_TYPES.CONFIGURATION_ERROR);
+  });
+
+  test('classifyError uses context.operation for additional classification', () => {
+    const error = new Error('Something generic');
+    const info = handler.classifyError(error, { operation: 'api_request' });
+    expect(info.type).toBe(ERROR_TYPES.RATE_LIMIT_EXCEEDED);
+  });
+
+  test('classifyError sets agentId, toolId, operationId from context', () => {
+    const error = new Error('fail');
+    const info = handler.classifyError(error, { agentId: 'a1', toolId: 't1', operationId: 'op1' });
+    expect(info.agentId).toBe('a1');
+    expect(info.toolId).toBe('t1');
+    expect(info.operationId).toBe('op1');
+  });
+
+  test('classifyError returns UNKNOWN_ERROR for unrecognizable errors', () => {
+    const error = new Error('something completely random with no keywords');
+    const info = handler.classifyError(error);
+    expect(info.type).toBe(ERROR_TYPES.UNKNOWN_ERROR);
+  });
+
+  // --- determineSeverity ---
+
+  test('determineSeverity returns critical for authentication errors', () => {
+    const error = new Error('Auth');
+    error.status = HTTP_STATUS.UNAUTHORIZED;
+    expect(handler.determineSeverity(error, {})).toBe('critical');
+  });
+
+  test('determineSeverity returns high for rate limit errors', () => {
+    const error = new Error('Rate limit');
+    error.status = HTTP_STATUS.TOO_MANY_REQUESTS;
+    expect(handler.determineSeverity(error, {})).toBe('high');
+  });
+
+  test('determineSeverity returns high when retryCount >= 3', () => {
+    const error = new Error('generic random error no keywords');
+    expect(handler.determineSeverity(error, { retryCount: 3 })).toBe('high');
+  });
+
+  test('determineSeverity returns medium for agent communication', () => {
+    const error = new Error('something random no keywords');
+    expect(handler.determineSeverity(error, { agentId: 'a1', operation: 'agent_communication' })).toBe('medium');
+  });
+
+  test('determineSeverity returns low for generic low-priority errors', () => {
+    const error = new Error('some problem');
+    error.code = 'ENOENT';
+    expect(handler.determineSeverity(error, {})).toBe('low');
+  });
+
+  // --- isRecoverable ---
+
+  test('isRecoverable returns false for AUTHENTICATION_FAILED', () => {
+    const info = handler.classifyError(Object.assign(new Error('auth'), { status: HTTP_STATUS.UNAUTHORIZED }));
+    expect(info.recoverable).toBe(false);
+  });
+
+  test('isRecoverable returns false when retryCount >= maxRetries', () => {
+    const info = { type: ERROR_TYPES.FILE_NOT_FOUND, retryCount: 5, maxRetries: 2, severity: 'low' };
+    expect(handler.isRecoverable(info)).toBe(false);
+  });
+
+  test('isRecoverable returns true for transient recoverable errors', () => {
+    const info = { type: ERROR_TYPES.OPERATION_TIMEOUT, retryCount: 0, maxRetries: 3, severity: 'high' };
+    expect(handler.isRecoverable(info)).toBe(true);
+  });
+
+  // --- calculateRetryDelay ---
+
+  test('calculateRetryDelay returns increasing delays with exponential backoff', () => {
+    const delay0 = handler.calculateRetryDelay({ retryCount: 0 });
+    // Base delay = 1000 * 2^0 + jitter(0-1000) = 1000-2000
+    expect(delay0).toBeGreaterThanOrEqual(1000);
+    expect(delay0).toBeLessThanOrEqual(2000);
+  });
+
+  test('calculateRetryDelay caps at 30000ms', () => {
+    const delay = handler.calculateRetryDelay({ retryCount: 20 });
+    expect(delay).toBeLessThanOrEqual(30000);
+  });
+
+  // --- subscribe / notifySubscribers ---
+
+  test('subscribe registers a callback and unsubscribe removes it', () => {
+    const cb = jest.fn();
+    const unsub = handler.subscribe(cb);
+    handler.notifySubscribers({ id: 'err1' }, { success: true });
+    expect(cb).toHaveBeenCalledTimes(1);
+    expect(cb).toHaveBeenCalledWith({ id: 'err1' }, { success: true });
+
+    unsub();
+    handler.notifySubscribers({ id: 'err2' }, { success: false });
+    expect(cb).toHaveBeenCalledTimes(1); // not called again
+  });
+
+  test('notifySubscribers logs error if callback throws', () => {
+    handler.subscribe(() => { throw new Error('boom'); });
+    handler.notifySubscribers({}, {});
+    expect(logger.error).toHaveBeenCalledWith('Error subscriber callback failed', expect.any(Object));
+  });
+
+  // --- getErrorStats / clearErrorStats / updateErrorStats ---
+
+  test('getErrorStats returns accumulated stats with type and agent counts', () => {
+    handler.updateErrorStats({ type: ERROR_TYPES.FILE_NOT_FOUND, agentId: 'a1' });
+    handler.updateErrorStats({ type: ERROR_TYPES.FILE_NOT_FOUND });
+    handler.updateErrorStats({ type: ERROR_TYPES.OPERATION_TIMEOUT, agentId: 'a1' });
+    const stats = handler.getErrorStats();
+    expect(stats.totalErrors).toBe(3);
+    expect(stats.errorsByType[ERROR_TYPES.FILE_NOT_FOUND]).toBe(2);
+    expect(stats.errorsByType[ERROR_TYPES.OPERATION_TIMEOUT]).toBe(1);
+    expect(stats.errorsByAgent['a1']).toBe(2);
+  });
+
+  test('clearErrorStats resets all counters and empties queue', () => {
+    handler.updateErrorStats({ type: ERROR_TYPES.FILE_NOT_FOUND });
+    handler.errorQueue.push({ test: true });
+    handler.clearErrorStats();
+    const stats = handler.getErrorStats();
+    expect(stats.totalErrors).toBe(0);
+    expect(stats.queueLength).toBe(0);
+    expect(stats.recoveryAttempts).toBe(0);
+    expect(stats.successfulRecoveries).toBe(0);
+    expect(stats.criticalErrors).toBe(0);
+  });
+
+  test('getErrorStats computes recoverySuccessRate correctly', () => {
+    handler.errorStats.recoveryAttempts = 10;
+    handler.errorStats.successfulRecoveries = 7;
+    const stats = handler.getErrorStats();
+    expect(stats.recoverySuccessRate).toBeCloseTo(0.7);
+  });
+
+  // --- handleError full pipeline ---
+
+  test('handleError classifies, processes, updates stats and notifies subscribers', async () => {
+    const cb = jest.fn();
+    handler.subscribe(cb);
+
+    const error = new Error('Request timed out');
+    const result = await handler.handleError(error, { retryCount: 0 });
+
+    expect(result).toBeDefined();
+    expect(result.errorType).toBe(ERROR_TYPES.OPERATION_TIMEOUT);
+    expect(result.severity).toBe('high');
+    expect(result.errorId).toMatch(/^err_/);
+    expect(cb).toHaveBeenCalledTimes(1);
+
+    const stats = handler.getErrorStats();
+    expect(stats.totalErrors).toBe(1);
+  });
+
+  test('handleError returns fallback result when internal processing throws', async () => {
+    handler.processError = jest.fn().mockRejectedValue(new Error('processing failed'));
+
+    const result = await handler.handleError(new Error('test'), {});
+    expect(result.success).toBe(false);
+    expect(result.severity).toBe('critical');
+  });
+
+  // --- shouldRetry ---
+
+  test('shouldRetry returns false when recovery succeeded', () => {
+    const info = { recoverable: true, retryCount: 0, maxRetries: 3 };
+    expect(handler.shouldRetry(info, { success: true })).toBe(false);
+  });
+
+  test('shouldRetry returns true when recoverable and recovery failed', () => {
+    const info = { recoverable: true, retryCount: 0, maxRetries: 3 };
+    expect(handler.shouldRetry(info, { success: false })).toBe(true);
+  });
+
+  test('shouldRetry returns false when not recoverable', () => {
+    const info = { recoverable: false, retryCount: 0, maxRetries: 3 };
+    expect(handler.shouldRetry(info, null)).toBe(false);
+  });
+
+  // --- getMaxRetries ---
+
+  test('getMaxRetries returns 5 for RATE_LIMIT_EXCEEDED', () => {
+    const error = new Error('rate');
+    error.status = HTTP_STATUS.TOO_MANY_REQUESTS;
+    expect(handler.getMaxRetries(error, {})).toBe(5);
+  });
+
+  test('getMaxRetries returns 3 for OPERATION_TIMEOUT', () => {
+    const error = new Error('request timed out');
+    expect(handler.getMaxRetries(error, {})).toBe(3);
+  });
+
+  // --- handleCriticalError / processError ---
+
+  test('processError handles critical error by calling handleCriticalError', async () => {
+    const error = new Error('auth fail');
+    error.status = HTTP_STATUS.UNAUTHORIZED;
+    const errorInfo = handler.classifyError(error);
+    // severity should be critical
+    expect(errorInfo.severity).toBe('critical');
+
+    const spy = jest.spyOn(handler, 'handleCriticalError');
+    await handler.processError(errorInfo);
+    expect(spy).toHaveBeenCalledWith(errorInfo);
+  });
+
+  test('processError returns failure result when internal error occurs', async () => {
+    const errorInfo = {
+      id: 'err_test', type: ERROR_TYPES.FILE_NOT_FOUND, severity: 'low',
+      message: 'test', recoverable: true, retryCount: 0, maxRetries: 3
+    };
+    // Force logError to throw
+    handler.logError = jest.fn().mockRejectedValue(new Error('log broken'));
+    const result = await handler.processError(errorInfo);
+    expect(result.success).toBe(false);
+    expect(result.severity).toBe('critical');
+  });
+});

package/src/services/__tests__/fileAttachmentService.test.js

@@ -0,0 +1,278 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+// Mock dependencies
+const mockFileProcessor = {
+  createDirectory: jest.fn().mockResolvedValue(undefined),
+  fileExists: jest.fn().mockResolvedValue(true),
+  readFile: jest.fn().mockResolvedValue('{}'),
+  writeFile: jest.fn().mockResolvedValue(undefined),
+  getFileStats: jest.fn().mockResolvedValue({ size: 1024, modified: new Date() }),
+  calculateHash: jest.fn().mockResolvedValue('abc123hash'),
+  processFile: jest.fn().mockResolvedValue({ content: 'processed content' }),
+  estimateTokens: jest.fn().mockReturnValue(100),
+  deleteDirectory: jest.fn().mockResolvedValue(undefined)
+};
+
+const mockValidator = {
+  validate: jest.fn().mockReturnValue({ valid: true, errors: [], warnings: [], sizeLevel: 'small' }),
+  getContentType: jest.fn().mockReturnValue('text'),
+  getMimeType: jest.fn().mockReturnValue('text/plain')
+};
+
+jest.unstable_mockModule('../../utilities/fileProcessor.js', () => ({
+  default: jest.fn().mockImplementation(() => mockFileProcessor)
+}));
+
+jest.unstable_mockModule('../../utilities/attachmentValidator.js', () => ({
+  default: jest.fn().mockImplementation(() => mockValidator)
+}));
+
+jest.unstable_mockModule('../../utilities/userDataDir.js', () => ({
+  getUserDataPaths: jest.fn(() => ({
+    settings: '/fake/settings',
+    attachments: '/fake/attachments',
+    skills: '/fake/skills'
+  })),
+  ensureUserDataDirs: jest.fn(async () => {})
+}));
+
+jest.unstable_mockModule('crypto', () => ({
+  randomUUID: jest.fn(() => 'test-uuid-1234')
+}));
+
+const { default: FileAttachmentService } = await import('../fileAttachmentService.js');
+
+describe('FileAttachmentService', () => {
+  let service;
+  let logger;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logger = createMockLogger();
+    service = new FileAttachmentService({}, logger);
+    // Reset index to avoid stale state
+    service.index = null;
+  });
+
+  test('constructor initializes with null index', () => {
+    expect(service.index).toBeNull();
+  });
+
+  test('initialize creates directory and loads index', async () => {
+    mockFileProcessor.fileExists.mockResolvedValueOnce(false);
+    mockFileProcessor.writeFile.mockResolvedValue(undefined);
+
+    await service.initialize();
+    expect(mockFileProcessor.createDirectory).toHaveBeenCalled();
+    expect(logger.info).toHaveBeenCalled();
+  });
+
+  test('initialize throws on error', async () => {
+    mockFileProcessor.createDirectory.mockRejectedValueOnce(new Error('no dir'));
+    await expect(service.initialize()).rejects.toThrow('no dir');
+  });
+
+  test('loadIndex creates new index when file does not exist', async () => {
+    mockFileProcessor.fileExists.mockResolvedValueOnce(false);
+    mockFileProcessor.writeFile.mockResolvedValue(undefined);
+
+    const index = await service.loadIndex();
+    expect(index).toEqual({ attachments: {}, agentRefs: {} });
+  });
+
+  test('loadIndex loads existing index', async () => {
+    const existingIndex = { attachments: { f1: {} }, agentRefs: { a1: ['f1'] } };
+    mockFileProcessor.fileExists.mockResolvedValueOnce(true);
+    mockFileProcessor.readFile.mockResolvedValueOnce(JSON.stringify(existingIndex));
+
+    const index = await service.loadIndex();
+    expect(index.attachments.f1).toBeDefined();
+  });
+
+  test('loadIndex handles read error with default', async () => {
+    mockFileProcessor.fileExists.mockRejectedValueOnce(new Error('read fail'));
+    const index = await service.loadIndex();
+    expect(index).toEqual({ attachments: {}, agentRefs: {} });
+  });
+
+  test('saveIndex writes JSON to file', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    await service.saveIndex();
+    expect(mockFileProcessor.writeFile).toHaveBeenCalled();
+  });
+
+  test('uploadFile creates attachment metadata', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.getFileStats.mockResolvedValue({ size: 512, modified: new Date() });
+    mockFileProcessor.processFile.mockResolvedValue({ content: 'text content' });
+    mockFileProcessor.estimateTokens.mockReturnValue(50);
+    mockFileProcessor.writeFile.mockResolvedValue(undefined);
+    mockFileProcessor.createDirectory.mockResolvedValue(undefined);
+    mockValidator.validate.mockReturnValue({ valid: true, errors: [], warnings: [], sizeLevel: 'small' });
+
+    const result = await service.uploadFile({
+      agentId: 'agent-1',
+      filePath: '/path/to/file.txt',
+      mode: 'content'
+    });
+
+    expect(result.fileId).toBe('test-uuid-1234');
+    expect(result.agentId).toBe('agent-1');
+    expect(result.mode).toBe('content');
+    expect(service.index.attachments['test-uuid-1234']).toBeDefined();
+  });
+
+  test('uploadFile throws for non-existent file', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValueOnce(false);
+
+    await expect(service.uploadFile({
+      agentId: 'agent-1',
+      filePath: '/missing.txt'
+    })).rejects.toThrow('File not found');
+  });
+
+  test('uploadFile throws on validation failure', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValueOnce(true);
+    mockFileProcessor.getFileStats.mockResolvedValue({ size: 999999999, modified: new Date() });
+    mockValidator.validate.mockReturnValue({ valid: false, errors: ['Too large'], warnings: [] });
+
+    await expect(service.uploadFile({
+      agentId: 'agent-1',
+      filePath: '/big.txt'
+    })).rejects.toThrow('Validation failed');
+  });
+
+  test('uploadFile handles reference mode', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.getFileStats.mockResolvedValue({ size: 512, modified: new Date() });
+    mockValidator.validate.mockReturnValue({ valid: true, errors: [], warnings: [], sizeLevel: 'small' });
+
+    const result = await service.uploadFile({
+      agentId: 'agent-1',
+      filePath: '/path/ref.js',
+      mode: 'reference'
+    });
+
+    expect(result.mode).toBe('reference');
+    expect(result.tokenEstimate).toBe(0);
+  });
+
+  test('getAttachments returns filtered attachments', async () => {
+    service.index = {
+      attachments: { f1: { fileId: 'f1', agentId: 'a1', fileName: 'a.txt', mode: 'content', active: true } },
+      agentRefs: { a1: ['f1'] }
+    };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.readFile.mockResolvedValue(JSON.stringify({
+      fileId: 'f1', agentId: 'a1', active: true, mode: 'content'
+    }));
+
+    const results = await service.getAttachments('a1');
+    expect(results).toHaveLength(1);
+  });
+
+  test('getAttachments loads index if null', async () => {
+    service.index = null;
+    mockFileProcessor.fileExists.mockResolvedValueOnce(false);
+    mockFileProcessor.writeFile.mockResolvedValue(undefined);
+
+    const results = await service.getAttachments('a1');
+    expect(results).toEqual([]);
+  });
+
+  test('getAttachment returns null for unknown fileId', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    const result = await service.getAttachment('unknown');
+    expect(result).toBeNull();
+  });
+
+  test('getAttachment returns null when metadata file missing', async () => {
+    service.index = { attachments: { f1: { fileId: 'f1', agentId: 'a1' } }, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValueOnce(false);
+    const result = await service.getAttachment('f1');
+    expect(result).toBeNull();
+  });
+
+  test('getAttachmentContent returns null for reference mode', async () => {
+    service.index = { attachments: { f1: { fileId: 'f1', agentId: 'a1' } }, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValueOnce(true);
+    mockFileProcessor.readFile.mockResolvedValueOnce(JSON.stringify({ mode: 'reference', agentId: 'a1' }));
+
+    const content = await service.getAttachmentContent('f1');
+    expect(content).toBeNull();
+  });
+
+  test('toggleActive flips active state', async () => {
+    service.index = { attachments: { f1: { fileId: 'f1', agentId: 'a1', active: true } }, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.readFile.mockResolvedValueOnce(JSON.stringify({
+      fileId: 'f1', agentId: 'a1', active: true
+    }));
+
+    const result = await service.toggleActive('f1');
+    expect(result.active).toBe(false);
+  });
+
+  test('toggleActive throws for missing attachment', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    await expect(service.toggleActive('unknown')).rejects.toThrow('Attachment not found');
+  });
+
+  test('deleteAttachment removes when no other references', async () => {
+    service.index = {
+      attachments: { f1: { fileId: 'f1', agentId: 'a1' } },
+      agentRefs: { a1: ['f1'] }
+    };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.readFile.mockResolvedValueOnce(JSON.stringify({
+      fileId: 'f1', agentId: 'a1', referencedBy: ['a1']
+    }));
+
+    const deleted = await service.deleteAttachment('f1', 'a1');
+    expect(deleted).toBe(true);
+    expect(mockFileProcessor.deleteDirectory).toHaveBeenCalled();
+  });
+
+  test('deleteAttachment derefs when still referenced', async () => {
+    service.index = {
+      attachments: { f1: { fileId: 'f1', agentId: 'a1' } },
+      agentRefs: { a1: ['f1'] }
+    };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.readFile.mockResolvedValueOnce(JSON.stringify({
+      fileId: 'f1', agentId: 'a1', referencedBy: ['a1', 'a2']
+    }));
+
+    const deleted = await service.deleteAttachment('f1', 'a1');
+    expect(deleted).toBe(false);
+  });
+
+  test('getAttachmentPreview returns truncated content', async () => {
+    service.index = { attachments: { f1: { fileId: 'f1', agentId: 'a1' } }, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    const metadata = { fileId: 'f1', agentId: 'a1', mode: 'content', contentFileName: 'content.txt' };
+    mockFileProcessor.readFile
+      .mockResolvedValueOnce(JSON.stringify(metadata)) // getAttachment
+      .mockResolvedValueOnce('x'.repeat(2000)); // getAttachmentContent
+
+    const preview = await service.getAttachmentPreview('f1');
+    expect(preview.length).toBe(1003); // 1000 + '...'
+  });
+
+  test('getAttachmentPreview returns image placeholder', async () => {
+    service.index = { attachments: { f1: { fileId: 'f1', agentId: 'a1' } }, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    const metadata = { fileId: 'f1', agentId: 'a1', mode: 'content', contentFileName: 'content.base64' };
+    mockFileProcessor.readFile
+      .mockResolvedValueOnce(JSON.stringify(metadata))
+      .mockResolvedValueOnce('data:image/png;base64,abc');
+
+    const preview = await service.getAttachmentPreview('f1');
+    expect(preview).toBe('[Image content - base64 encoded]');
+  });
+});