cc-lark 0.1.1

package/tests/tools/im/format-messages.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Tests for IM tools message formatting.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  extractMentionOpenId,
+  convertMessageContent,
+  buildConvertContextFromItem,
+  type ApiMessageItem,
+} from '../../../src/tools/im/format-messages.js';
+
+describe('format-messages', () => {
+  describe('extractMentionOpenId', () => {
+    it('should extract open_id from string', () => {
+      expect(extractMentionOpenId('ou_abc123')).toBe('ou_abc123');
+    });
+
+    it('should extract open_id from object', () => {
+      expect(extractMentionOpenId({ open_id: 'ou_abc123' })).toBe('ou_abc123');
+    });
+
+    it('should return empty string for null', () => {
+      expect(extractMentionOpenId(null)).toBe('');
+    });
+
+    it('should return empty string for undefined', () => {
+      expect(extractMentionOpenId(undefined)).toBe('');
+    });
+
+    it('should return empty string for object without open_id', () => {
+      expect(extractMentionOpenId({ user_id: 'abc' })).toBe('');
+    });
+  });
+
+  describe('convertMessageContent', () => {
+    const ctx = {
+      messageId: 'test-msg',
+    };
+
+    it('should convert text message', () => {
+      const content = JSON.stringify({ text: 'Hello world' });
+      const result = convertMessageContent(content, 'text', ctx);
+      expect(result).toBe('Hello world');
+    });
+
+    it('should convert image message', () => {
+      const content = JSON.stringify({ image_key: 'img_abc123' });
+      const result = convertMessageContent(content, 'image', ctx);
+      expect(result).toBe('[Image: img_abc123]');
+    });
+
+    it('should convert file message', () => {
+      const content = JSON.stringify({ file_key: 'file_abc123', file_name: 'document.pdf' });
+      const result = convertMessageContent(content, 'file', ctx);
+      expect(result).toBe('[File: document.pdf]');
+    });
+
+    it('should convert audio message', () => {
+      const content = JSON.stringify({ file_key: 'file_abc123', file_name: 'recording.mp3' });
+      const result = convertMessageContent(content, 'audio', ctx);
+      expect(result).toBe('[Audio: recording.mp3]');
+    });
+
+    it('should convert media message', () => {
+      const content = JSON.stringify({ media_key: 'media_abc123', file_name: 'video.mp4' });
+      const result = convertMessageContent(content, 'media', ctx);
+      expect(result).toBe('[Media: video.mp4]');
+    });
+
+    it('should convert sticker message', () => {
+      const content = JSON.stringify({ file_key: 'sticker_abc123' });
+      const result = convertMessageContent(content, 'sticker', ctx);
+      expect(result).toBe('[Sticker: sticker_abc123]');
+    });
+
+    it('should convert interactive card message', () => {
+      const content = JSON.stringify({});
+      const result = convertMessageContent(content, 'interactive', ctx);
+      expect(result).toBe('[Interactive Card]');
+    });
+
+    it('should convert share_chat message', () => {
+      const content = JSON.stringify({ chat_id: 'oc_abc123' });
+      const result = convertMessageContent(content, 'share_chat', ctx);
+      expect(result).toBe('[Share Chat: oc_abc123]');
+    });
+
+    it('should convert share_user message', () => {
+      const content = JSON.stringify({ user_id: 'ou_abc123' });
+      const result = convertMessageContent(content, 'share_user', ctx);
+      expect(result).toBe('[Share User: ou_abc123]');
+    });
+
+    it('should convert merge_forward message', () => {
+      const content = JSON.stringify({});
+      const result = convertMessageContent(content, 'merge_forward', ctx);
+      expect(result).toBe('[Merged Forwarded Messages]');
+    });
+
+    it('should convert post message with title and content', () => {
+      const content = JSON.stringify({
+        zh_cn: {
+          title: 'Title',
+          content: [
+            [{ tag: 'text', text: 'Line 1' }],
+            [{ tag: 'text', text: 'Line 2' }],
+          ],
+        },
+      });
+      const result = convertMessageContent(content, 'post', ctx);
+      expect(result).toContain('Title');
+      expect(result).toContain('Line 1');
+      expect(result).toContain('Line 2');
+    });
+
+    it('should return raw content for unknown message type', () => {
+      const content = '{"custom": "data"}';
+      const result = convertMessageContent(content, 'unknown_type', ctx);
+      expect(result).toBe('{"custom": "data"}');
+    });
+
+    it('should return raw content for invalid JSON', () => {
+      const content = 'not valid json';
+      const result = convertMessageContent(content, 'text', ctx);
+      expect(result).toBe('not valid json');
+    });
+
+    it('should handle empty content', () => {
+      const result = convertMessageContent('', 'text', ctx);
+      expect(result).toBe('');
+    });
+  });
+
+  describe('buildConvertContextFromItem', () => {
+    it('should build context from API message item', () => {
+      const item: ApiMessageItem = {
+        message_id: 'om_test123',
+        msg_type: 'text',
+        body: { content: '{"text":"hello"}' },
+        sender: { id: 'ou_sender', sender_type: 'user' },
+        mentions: [
+          { key: '@_user_1', id: 'ou_mentioned', name: 'John' },
+        ],
+      };
+
+      const ctx = buildConvertContextFromItem(item, 'fallback-id', 'account-1');
+
+      expect(ctx.messageId).toBe('om_test123');
+      expect(ctx.accountId).toBe('account-1');
+      // mentions and mentionsByOpenId are internal Maps, not exposed on ConvertContext
+    });
+
+    it('should use fallback message ID if not present', () => {
+      const item: ApiMessageItem = {};
+      const ctx = buildConvertContextFromItem(item, 'fallback-id');
+
+      expect(ctx.messageId).toBe('fallback-id');
+    });
+
+    it('should handle empty mentions', () => {
+      const item: ApiMessageItem = {
+        message_id: 'om_test',
+        mentions: [],
+      };
+
+      const ctx = buildConvertContextFromItem(item, 'fallback');
+      // mentions and mentionsByOpenId are internal Maps, not exposed on ConvertContext
+      expect(ctx.messageId).toBe('om_test');
+    });
+
+    it('should handle missing mentions', () => {
+      const item: ApiMessageItem = {
+        message_id: 'om_test',
+      };
+
+      const ctx = buildConvertContextFromItem(item, 'fallback');
+      expect(ctx.messageId).toBe('om_test');
+    });
+  });
+});

package/tests/tools/im/time-utils.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Tests for IM tools time utilities.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  secondsToDateTime,
+  secondsStringToDateTime,
+  millisToDateTime,
+  millisStringToDateTime,
+  dateTimeToSeconds,
+  dateTimeToSecondsString,
+  dateTimeToMillis,
+  parseTimeRange,
+  parseTimeRangeToSeconds,
+  parseTimeToTimestamp,
+  unixTimestampToISO8601,
+} from '../../../src/tools/im/time-utils.js';
+
+// 2026-03-14 20:00:00+08:00 = 2026-03-14 12:00:00 UTC
+const TEST_TIMESTAMP_SECONDS = 1773489600;
+const TEST_TIMESTAMP_MILLIS = 1773489600000;
+const TEST_ISO = '2026-03-14T20:00:00+08:00';
+
+describe('time-utils', () => {
+  describe('secondsToDateTime', () => {
+    it('should convert Unix seconds to ISO 8601 Beijing time', () => {
+      const result = secondsToDateTime(TEST_TIMESTAMP_SECONDS);
+      expect(result).toBe(TEST_ISO);
+    });
+
+    it('should handle epoch', () => {
+      const result = secondsToDateTime(0);
+      expect(result).toBe('1970-01-01T08:00:00+08:00');
+    });
+  });
+
+  describe('secondsStringToDateTime', () => {
+    it('should convert Unix seconds string to ISO 8601', () => {
+      const result = secondsStringToDateTime(String(TEST_TIMESTAMP_SECONDS));
+      expect(result).toBe(TEST_ISO);
+    });
+  });
+
+  describe('millisToDateTime', () => {
+    it('should convert Unix milliseconds to ISO 8601', () => {
+      const result = millisToDateTime(TEST_TIMESTAMP_MILLIS);
+      expect(result).toBe(TEST_ISO);
+    });
+  });
+
+  describe('millisStringToDateTime', () => {
+    it('should convert Unix milliseconds string to ISO 8601', () => {
+      const result = millisStringToDateTime(String(TEST_TIMESTAMP_MILLIS));
+      expect(result).toBe(TEST_ISO);
+    });
+  });
+
+  describe('dateTimeToSeconds', () => {
+    it('should convert ISO 8601 to Unix seconds', () => {
+      const result = dateTimeToSeconds(TEST_ISO);
+      expect(result).toBe(TEST_TIMESTAMP_SECONDS);
+    });
+
+    it('should throw for invalid date format', () => {
+      expect(() => dateTimeToSeconds('invalid')).toThrow();
+    });
+  });
+
+  describe('dateTimeToSecondsString', () => {
+    it('should convert ISO 8601 to Unix seconds string', () => {
+      const result = dateTimeToSecondsString(TEST_ISO);
+      expect(result).toBe(String(TEST_TIMESTAMP_SECONDS));
+    });
+  });
+
+  describe('dateTimeToMillis', () => {
+    it('should convert ISO 8601 to Unix milliseconds', () => {
+      const result = dateTimeToMillis(TEST_ISO);
+      expect(result).toBe(TEST_TIMESTAMP_MILLIS);
+    });
+  });
+
+  describe('parseTimeRange', () => {
+    it('should parse "today"', () => {
+      const result = parseTimeRange('today');
+      expect(result.start).toMatch(/^\d{4}-\d{2}-\d{2}T00:00:00\+08:00$/);
+      expect(result.end).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00$/);
+    });
+
+    it('should parse "yesterday"', () => {
+      const result = parseTimeRange('yesterday');
+      expect(result.start).toMatch(/^\d{4}-\d{2}-\d{2}T00:00:00\+08:00$/);
+      expect(result.end).toMatch(/^\d{4}-\d{2}-\d{2}T23:59:59\+08:00$/);
+    });
+
+    it('should parse "this_week"', () => {
+      const result = parseTimeRange('this_week');
+      expect(result.start).toMatch(/^\d{4}-\d{2}-\d{2}T00:00:00\+08:00$/);
+      expect(result.end).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00$/);
+    });
+
+    it('should parse "this_month"', () => {
+      const result = parseTimeRange('this_month');
+      expect(result.start).toMatch(/^\d{4}-\d{2}-01T00:00:00\+08:00$/);
+      expect(result.end).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00$/);
+    });
+
+    it('should parse "last_3_days"', () => {
+      const result = parseTimeRange('last_3_days');
+      expect(result.start).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00$/);
+      expect(result.end).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00$/);
+    });
+
+    it('should parse "last_60_minutes"', () => {
+      const result = parseTimeRange('last_60_minutes');
+      expect(result.start).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00$/);
+      expect(result.end).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00$/);
+    });
+
+    it('should throw for unsupported format', () => {
+      expect(() => parseTimeRange('invalid')).toThrow();
+    });
+  });
+
+  describe('parseTimeRangeToSeconds', () => {
+    it('should return Unix seconds for time range', () => {
+      const result = parseTimeRangeToSeconds('today');
+      expect(result.start).toMatch(/^\d+$/);
+      expect(result.end).toMatch(/^\d+$/);
+    });
+  });
+
+  describe('parseTimeToTimestamp', () => {
+    it('should parse ISO 8601 with timezone', () => {
+      const result = parseTimeToTimestamp(TEST_ISO);
+      expect(result).toBe(String(TEST_TIMESTAMP_SECONDS));
+    });
+
+    it('should parse ISO 8601 without timezone (default to Beijing)', () => {
+      // 2026-03-14 20:00 Beijing = same as above
+      const result = parseTimeToTimestamp('2026-03-14 20:00');
+      expect(result).toBe(String(TEST_TIMESTAMP_SECONDS));
+    });
+
+    it('should parse ISO 8601 with T separator without timezone', () => {
+      const result = parseTimeToTimestamp('2026-03-14T20:00:00');
+      expect(result).toBe(String(TEST_TIMESTAMP_SECONDS));
+    });
+
+    it('should return null for invalid format', () => {
+      expect(parseTimeToTimestamp('invalid')).toBeNull();
+    });
+  });
+
+  describe('unixTimestampToISO8601', () => {
+    it('should convert Unix seconds to ISO 8601', () => {
+      const result = unixTimestampToISO8601(TEST_TIMESTAMP_SECONDS);
+      expect(result).toBe(TEST_ISO);
+    });
+
+    it('should convert Unix milliseconds to ISO 8601', () => {
+      const result = unixTimestampToISO8601(TEST_TIMESTAMP_MILLIS);
+      expect(result).toBe(TEST_ISO);
+    });
+
+    it('should return null for undefined', () => {
+      expect(unixTimestampToISO8601(undefined)).toBeNull();
+    });
+
+    it('should return null for invalid input', () => {
+      expect(unixTimestampToISO8601('invalid')).toBeNull();
+    });
+  });
+});

package/tests/utils/logger.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Tests for the logger utility.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { logger, defaultLogger } from '../../src/utils/logger.js';
+
+describe('logger', () => {
+  // Mock console methods
+  const originalConsole = {
+    log: console.log,
+    debug: console.debug,
+    warn: console.warn,
+    error: console.error,
+  };
+
+  beforeEach(() => {
+    console.log = vi.fn();
+    console.debug = vi.fn();
+    console.warn = vi.fn();
+    console.error = vi.fn();
+  });
+
+  afterEach(() => {
+    console.log = originalConsole.log;
+    console.debug = originalConsole.debug;
+    console.warn = originalConsole.warn;
+    console.error = originalConsole.error;
+  });
+
+  describe('logger factory', () => {
+    it('should create a logger with the correct subsystem', () => {
+      const log = logger('test');
+      expect(log.subsystem).toBe('test');
+    });
+
+    it('should create child loggers with nested subsystems', () => {
+      const log = logger('parent');
+      const child = log.child('child');
+      expect(child.subsystem).toBe('parent/child');
+
+      const grandchild = child.child('grandchild');
+      expect(grandchild.subsystem).toBe('parent/child/grandchild');
+    });
+  });
+
+  describe('logging methods', () => {
+    it('should call console.debug for debug level', () => {
+      const log = logger('test');
+      log.debug('test message');
+
+      expect(console.debug).toHaveBeenCalled();
+      const call = (console.debug as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(call[1]).toContain('cc-lark/test');
+      expect(call[1]).toContain('test message');
+    });
+
+    it('should call console.log for info level', () => {
+      const log = logger('test');
+      log.info('test message');
+
+      expect(console.log).toHaveBeenCalled();
+      const call = (console.log as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(call[1]).toContain('cc-lark/test');
+      expect(call[1]).toContain('test message');
+    });
+
+    it('should call console.warn for warn level', () => {
+      const log = logger('test');
+      log.warn('test message');
+
+      expect(console.warn).toHaveBeenCalled();
+      const call = (console.warn as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(call[1]).toContain('cc-lark/test');
+      expect(call[1]).toContain('test message');
+    });
+
+    it('should call console.error for error level', () => {
+      const log = logger('test');
+      log.error('test message');
+
+      expect(console.error).toHaveBeenCalled();
+      const call = (console.error as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(call[1]).toContain('cc-lark/test');
+      expect(call[1]).toContain('test message');
+    });
+  });
+
+  describe('metadata handling', () => {
+    it('should format metadata in message', () => {
+      const log = logger('test');
+      log.info('test message', { key: 'value', count: 42 });
+
+      const call = (console.log as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(call[1]).toContain('key=value');
+      expect(call[1]).toContain('count=42');
+    });
+
+    it('should handle empty metadata', () => {
+      const log = logger('test');
+      log.info('test message', {});
+
+      const call = (console.log as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(call[1]).toContain('test message');
+    });
+
+    it('should handle null and undefined metadata values', () => {
+      const log = logger('test');
+      log.info('test message', { key: null, other: undefined });
+
+      const call = (console.log as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(call[1]).toContain('test message');
+    });
+
+    it('should stringify object values in metadata', () => {
+      const log = logger('test');
+      log.info('test message', { obj: { nested: 'value' } });
+
+      const call = (console.log as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(call[1]).toContain('obj={"nested":"value"}');
+    });
+  });
+
+  describe('defaultLogger', () => {
+    it('should have subsystem "core"', () => {
+      expect(defaultLogger.subsystem).toBe('core');
+    });
+
+    it('should be a valid logger instance', () => {
+      expect(typeof defaultLogger.info).toBe('function');
+      expect(typeof defaultLogger.debug).toBe('function');
+      expect(typeof defaultLogger.warn).toBe('function');
+      expect(typeof defaultLogger.error).toBe('function');
+      expect(typeof defaultLogger.child).toBe('function');
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}