opc-agent 1.4.0 → 2.0.1

package/tests/auto-learn.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { SkillLearner, skillToMarkdown, parseSkillMarkdown, type LearnedSkill } from '../src/skills/auto-learn';
+
+function makeSkill(overrides: Partial<LearnedSkill> = {}): LearnedSkill {
+  return {
+    name: 'test-skill',
+    description: 'A test skill',
+    trigger: 'deploy|deployment',
+    instructions: '1. Check env\n2. Run deploy\n3. Verify',
+    examples: ['deploy to production', 'run deployment'],
+    createdAt: new Date('2026-01-01T00:00:00Z'),
+    usageCount: 0,
+    version: 1,
+    ...overrides,
+  };
+}
+
+describe('SkillLearner', () => {
+  let tmpDir: string;
+  let learner: SkillLearner;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opc-skills-'));
+    learner = new SkillLearner(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('saveSkill / loadLearnedSkills', () => {
+    it('should save and load a skill', async () => {
+      const skill = makeSkill();
+      await learner.saveSkill(skill);
+
+      const loaded = await learner.loadLearnedSkills();
+      expect(loaded).toHaveLength(1);
+      expect(loaded[0].name).toBe('test-skill');
+      expect(loaded[0].description).toBe('A test skill');
+      expect(loaded[0].trigger).toBe('deploy|deployment');
+      expect(loaded[0].examples).toEqual(['deploy to production', 'run deployment']);
+    });
+
+    it('should create directory if not exists', async () => {
+      const nested = path.join(tmpDir, 'deep', 'nested');
+      const l = new SkillLearner(nested);
+      await l.saveSkill(makeSkill());
+      expect(fs.existsSync(path.join(nested, 'test-skill.md'))).toBe(true);
+    });
+
+    it('should return empty array for nonexistent dir', async () => {
+      const l = new SkillLearner(path.join(tmpDir, 'nope'));
+      const skills = await l.loadLearnedSkills();
+      expect(skills).toEqual([]);
+    });
+  });
+
+  describe('matchSkill', () => {
+    it('should match by regex pattern', async () => {
+      await learner.saveSkill(makeSkill({ trigger: 'deploy|deployment' }));
+      await learner.loadLearnedSkills();
+
+      expect(learner.matchSkill('please deploy to production')).not.toBeNull();
+      expect(learner.matchSkill('run deployment now')).not.toBeNull();
+      expect(learner.matchSkill('hello world')).toBeNull();
+    });
+
+    it('should match by keyword fallback for invalid regex', async () => {
+      // Use an actually invalid regex so the catch branch is triggered
+      await learner.saveSkill(makeSkill({ trigger: '(deploy[broken, kubernetes' }));
+      await learner.loadLearnedSkills();
+
+      expect(learner.matchSkill('kubernetes cluster')).not.toBeNull();
+      expect(learner.matchSkill('random text')).toBeNull();
+    });
+
+    it('should return null if not loaded', () => {
+      expect(learner.matchSkill('deploy')).toBeNull();
+    });
+  });
+
+  describe('skillToMarkdown / parseSkillMarkdown', () => {
+    it('should round-trip a skill through markdown', () => {
+      const skill = makeSkill();
+      const md = skillToMarkdown(skill);
+      const parsed = parseSkillMarkdown(md);
+
+      expect(parsed).not.toBeNull();
+      expect(parsed!.name).toBe(skill.name);
+      expect(parsed!.description).toBe(skill.description);
+      expect(parsed!.trigger).toBe(skill.trigger);
+      expect(parsed!.instructions).toBe(skill.instructions);
+      expect(parsed!.examples).toEqual(skill.examples);
+      expect(parsed!.version).toBe(1);
+      expect(parsed!.usageCount).toBe(0);
+    });
+
+    it('should return null for invalid markdown', () => {
+      expect(parseSkillMarkdown('just some text')).toBeNull();
+    });
+  });
+});

package/tests/builtin-tools.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { getBuiltinTools, getBuiltinToolsByName } from '../src/tools/builtin';
+import { fileTool, shellTool, datetimeTool } from '../src/tools/builtin';
+
+describe('getBuiltinTools', () => {
+  it('returns 4 tools', () => {
+    const tools = getBuiltinTools();
+    expect(tools).toHaveLength(4);
+    const names = tools.map(t => t.name);
+    expect(names).toContain('file_operations');
+    expect(names).toContain('web_fetch');
+    expect(names).toContain('shell_exec');
+    expect(names).toContain('datetime');
+  });
+
+  it('getBuiltinToolsByName filters correctly', () => {
+    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
+    expect(tools).toHaveLength(2);
+  });
+
+  it('getBuiltinToolsByName with no args returns all', () => {
+    expect(getBuiltinToolsByName()).toHaveLength(4);
+  });
+});
+
+describe('file_operations tool', () => {
+  // file tool resolves paths relative to cwd, so use relative paths from a temp dir
+  // Actually, it uses process.cwd() as workspace. Let's just test with paths relative to cwd.
+  const testFile = `tmp-test-${Date.now()}.txt`;
+
+  afterAll(() => {
+    try { require('fs').unlinkSync(testFile); } catch {}
+  });
+
+  it('write and read a file', async () => {
+    const writeRes = await fileTool.execute({ action: 'write', path: testFile, content: 'hello' });
+    expect(writeRes.isError).toBe(false);
+
+    const readRes = await fileTool.execute({ action: 'read', path: testFile });
+    expect(readRes.isError).toBe(false);
+    expect(readRes.content).toBe('hello');
+  });
+
+  it('list files', async () => {
+    const res = await fileTool.execute({ action: 'list', path: '.' });
+    expect(res.isError).toBe(false);
+    expect(res.content).toContain('package.json');
+  });
+
+  it('exists check', async () => {
+    const res = await fileTool.execute({ action: 'exists', path: testFile });
+    expect(res.content).toBe('true');
+
+    const res2 = await fileTool.execute({ action: 'exists', path: 'nope-does-not-exist.txt' });
+    expect(res2.content).toBe('false');
+  });
+
+  it('rejects path outside workspace', async () => {
+    const res = await fileTool.execute({ action: 'read', path: '../../etc/passwd' });
+    expect(res.isError).toBe(true);
+  });
+});
+
+describe('datetime tool', () => {
+  it('returns valid JSON with iso field', async () => {
+    const res = await datetimeTool.execute({});
+    expect(res.isError).toBe(false);
+    const parsed = JSON.parse(res.content);
+    expect(parsed.iso).toBeDefined();
+    expect(new Date(parsed.iso).toISOString()).toBe(parsed.iso);
+  });
+});
+
+describe('shell_exec tool', () => {
+  it('runs a command', async () => {
+    const res = await shellTool.execute({ command: 'echo hello' });
+    expect(res.isError).toBe(false);
+    expect(res.content).toContain('hello');
+  });
+});

package/tests/channels/discord.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi } from 'vitest';
+import { DiscordChannel } from '../../src/channels/discord';
+
+describe('DiscordChannel', () => {
+  it('constructor sets config from params', () => {
+    const ch = new DiscordChannel({ botToken: 'tok-123', applicationId: 'app-1' });
+    expect((ch as any).config.botToken).toBe('tok-123');
+    expect((ch as any).config.applicationId).toBe('app-1');
+  });
+
+  it('type is discord', () => {
+    const ch = new DiscordChannel({ botToken: 'tok' });
+    expect(ch.type).toBe('discord');
+  });
+
+  it('constructor reads token from env var', () => {
+    const orig = process.env.DISCORD_BOT_TOKEN;
+    process.env.DISCORD_BOT_TOKEN = 'env-discord-tok';
+    const ch = new DiscordChannel({});
+    expect((ch as any).config.botToken).toBe('env-discord-tok');
+    if (orig) process.env.DISCORD_BOT_TOKEN = orig;
+    else delete process.env.DISCORD_BOT_TOKEN;
+  });
+
+  it('defaults useThreads to true', () => {
+    const ch = new DiscordChannel({ botToken: 'tok' });
+    expect((ch as any).config.useThreads).toBe(true);
+  });
+
+  it('guildIds defaults to empty array', () => {
+    const ch = new DiscordChannel({ botToken: 'tok' });
+    expect((ch as any).config.guildIds).toEqual([]);
+  });
+
+  it('missing token results in empty string', () => {
+    const orig = process.env.DISCORD_BOT_TOKEN;
+    delete process.env.DISCORD_BOT_TOKEN;
+    const ch = new DiscordChannel({});
+    expect((ch as any).config.botToken).toBe('');
+    if (orig) process.env.DISCORD_BOT_TOKEN = orig;
+  });
+
+  it('start with no token warns but does not throw', async () => {
+    const orig = process.env.DISCORD_BOT_TOKEN;
+    delete process.env.DISCORD_BOT_TOKEN;
+    const ch = new DiscordChannel({});
+    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await ch.start();
+    expect(spy).toHaveBeenCalled();
+    spy.mockRestore();
+    if (orig) process.env.DISCORD_BOT_TOKEN = orig;
+  });
+
+  it('message chunking at 2000 chars', () => {
+    const longText = 'x'.repeat(3500);
+    const chunks: string[] = [];
+    for (let i = 0; i < longText.length; i += 2000) {
+      chunks.push(longText.slice(i, i + 2000));
+    }
+    expect(chunks).toHaveLength(2);
+    expect(chunks[0].length).toBe(2000);
+    expect(chunks[1].length).toBe(1500);
+  });
+
+  it('sequenceNumber starts null', () => {
+    const ch = new DiscordChannel({ botToken: 'tok' });
+    expect((ch as any).sequenceNumber).toBeNull();
+  });
+
+  it('ws starts null', () => {
+    const ch = new DiscordChannel({ botToken: 'tok' });
+    expect((ch as any).ws).toBeNull();
+  });
+
+  it('custom guildIds are set', () => {
+    const ch = new DiscordChannel({ botToken: 'tok', guildIds: ['g1', 'g2'] });
+    expect((ch as any).config.guildIds).toEqual(['g1', 'g2']);
+  });
+});

package/tests/channels/email.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect } from 'vitest';
+import { EmailChannel } from '../../src/channels/email';
+
+describe('EmailChannel', () => {
+  // ── Webhook Payload Parsing ──────────────────────
+
+  describe('parseWebhookPayload', () => {
+    it('should parse standard payload', () => {
+      const payload = {
+        from: 'alice@example.com',
+        to: ['bob@example.com'],
+        subject: 'Test Email',
+        body: 'Hello from email',
+        messageId: '<msg123@example.com>',
+        date: '2026-01-15T10:00:00Z',
+      };
+
+      const email = EmailChannel.parseWebhookPayload(payload);
+      expect(email).not.toBeNull();
+      expect(email!.from).toBe('alice@example.com');
+      expect(email!.to).toEqual(['bob@example.com']);
+      expect(email!.subject).toBe('Test Email');
+      expect(email!.body).toBe('Hello from email');
+      expect(email!.messageId).toBe('<msg123@example.com>');
+    });
+
+    it('should parse SendGrid-style payload', () => {
+      const payload = {
+        from: 'sender@test.com',
+        to: 'recipient@test.com',
+        subject: 'SG Test',
+        text: 'Body from SendGrid',
+        html: '<p>Body from SendGrid</p>',
+      };
+
+      const email = EmailChannel.parseWebhookPayload(payload);
+      expect(email).not.toBeNull();
+      expect(email!.body).toBe('Body from SendGrid');
+      expect(email!.html).toBe('<p>Body from SendGrid</p>');
+      expect(email!.to).toEqual(['recipient@test.com']);
+    });
+
+    it('should parse Mailgun-style payload', () => {
+      const payload = {
+        sender: 'mg@example.com',
+        recipient: 'user@example.com',
+        subject: 'MG Test',
+        'body-plain': 'Plain text body',
+        'body-html': '<p>HTML body</p>',
+        'Message-Id': '<mg123@mailgun>',
+      };
+
+      const email = EmailChannel.parseWebhookPayload(payload);
+      expect(email).not.toBeNull();
+      expect(email!.from).toBe('mg@example.com');
+      expect(email!.body).toBe('Plain text body');
+      expect(email!.messageId).toBe('<mg123@mailgun>');
+    });
+
+    it('should return null for payload without from', () => {
+      const email = EmailChannel.parseWebhookPayload({ subject: 'No sender' });
+      expect(email).toBeNull();
+    });
+
+    it('should handle envelope format', () => {
+      const payload = {
+        envelope: { from: 'env@test.com', to: ['a@b.com'] },
+        subject: 'Envelope test',
+        body: 'content',
+      };
+
+      const email = EmailChannel.parseWebhookPayload(payload);
+      expect(email).not.toBeNull();
+      expect(email!.from).toBe('env@test.com');
+    });
+
+    it('should generate messageId if missing', () => {
+      const payload = { from: 'a@b.com', body: 'test' };
+      const email = EmailChannel.parseWebhookPayload(payload);
+      expect(email).not.toBeNull();
+      expect(email!.messageId).toMatch(/^email-/);
+    });
+
+    it('should handle inReplyTo and references', () => {
+      const payload = {
+        from: 'a@b.com',
+        body: 'reply',
+        inReplyTo: '<orig@b.com>',
+        references: ['<orig@b.com>', '<prev@b.com>'],
+      };
+
+      const email = EmailChannel.parseWebhookPayload(payload);
+      expect(email!.inReplyTo).toBe('<orig@b.com>');
+      expect(email!.references).toEqual(['<orig@b.com>', '<prev@b.com>']);
+    });
+  });
+
+  // ── Filter Matching ──────────────────────────────
+
+  describe('matchesFilters', () => {
+    it('should match all when no filters', () => {
+      const channel = new EmailChannel({ mode: 'webhook' });
+      const result = channel.matchesFilters({
+        messageId: 'x', from: 'a@b.com', to: [], subject: 'test', body: '', date: new Date(),
+      });
+      expect(result).toBe(true);
+    });
+
+    it('should filter by from address', () => {
+      const channel = new EmailChannel({
+        mode: 'webhook',
+        filters: { from: ['allowed@example.com'] },
+      });
+
+      expect(channel.matchesFilters({
+        messageId: 'x', from: 'allowed@example.com', to: [], subject: '', body: '', date: new Date(),
+      })).toBe(true);
+
+      expect(channel.matchesFilters({
+        messageId: 'x', from: 'blocked@other.com', to: [], subject: '', body: '', date: new Date(),
+      })).toBe(false);
+    });
+
+    it('should filter by subject', () => {
+      const channel = new EmailChannel({
+        mode: 'webhook',
+        filters: { subject: ['[SUPPORT]'] },
+      });
+
+      expect(channel.matchesFilters({
+        messageId: 'x', from: 'a@b.com', to: [], subject: '[SUPPORT] Help me', body: '', date: new Date(),
+      })).toBe(true);
+
+      expect(channel.matchesFilters({
+        messageId: 'x', from: 'a@b.com', to: [], subject: 'Random email', body: '', date: new Date(),
+      })).toBe(false);
+    });
+  });
+
+  // ── Constructor ──────────────────────────────────
+
+  describe('constructor', () => {
+    it('should create with webhook mode', () => {
+      const channel = new EmailChannel({ mode: 'webhook', webhookPort: 9090 });
+      expect(channel.type).toBe('email');
+    });
+  });
+});

package/tests/channels/feishu.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect } from 'vitest';
+import { FeishuChannel } from '../../src/channels/feishu';
+
+describe('FeishuChannel', () => {
+  // ── Event Parsing ────────────────────────────────
+
+  describe('parseEventBody', () => {
+    it('should parse url_verification challenge', () => {
+      const body = { type: 'url_verification', challenge: 'abc123' };
+      const result = FeishuChannel.parseEventBody(body);
+      expect(result.type).toBe('url_verification');
+      expect(result.challenge).toBe('abc123');
+    });
+
+    it('should parse text message event', () => {
+      const body = {
+        header: {
+          event_id: 'evt_123',
+          event_type: 'im.message.receive_v1',
+          token: 'tok',
+        },
+        event: {
+          message: {
+            message_id: 'msg_123',
+            chat_id: 'oc_456',
+            message_type: 'text',
+            content: JSON.stringify({ text: 'Hello Feishu' }),
+            create_time: '1699999999',
+            chat_type: 'p2p',
+          },
+          sender: {
+            sender_id: { open_id: 'ou_789' },
+          },
+        },
+      };
+
+      const result = FeishuChannel.parseEventBody(body);
+      expect(result.type).toBe('message');
+      expect(result.content).toBe('Hello Feishu');
+      expect(result.chatId).toBe('oc_456');
+      expect(result.senderId).toBe('ou_789');
+      expect(result.messageId).toBe('msg_123');
+    });
+
+    it('should strip @bot mentions from content', () => {
+      const body = {
+        header: { event_type: 'im.message.receive_v1' },
+        event: {
+          message: {
+            message_id: 'msg_1',
+            chat_id: 'oc_1',
+            message_type: 'text',
+            content: JSON.stringify({ text: '@_user_123 Hello bot' }),
+          },
+          sender: { sender_id: { open_id: 'ou_1' } },
+        },
+      };
+
+      const result = FeishuChannel.parseEventBody(body);
+      expect(result.content).toBe('Hello bot');
+    });
+
+    it('should return empty content for non-text messages', () => {
+      const body = {
+        header: { event_type: 'im.message.receive_v1' },
+        event: {
+          message: {
+            message_id: 'msg_1',
+            chat_id: 'oc_1',
+            message_type: 'image',
+            content: '{}',
+          },
+          sender: { sender_id: { open_id: 'ou_1' } },
+        },
+      };
+
+      const result = FeishuChannel.parseEventBody(body);
+      expect(result.content).toBe('');
+    });
+
+    it('should handle unknown event types', () => {
+      const body = { header: { event_type: 'some.other.event' }, event: {} };
+      const result = FeishuChannel.parseEventBody(body);
+      expect(result.type).toBe('unknown');
+    });
+
+    it('should handle malformed content JSON gracefully', () => {
+      const body = {
+        header: { event_type: 'im.message.receive_v1' },
+        event: {
+          message: {
+            message_id: 'msg_1',
+            chat_id: 'oc_1',
+            message_type: 'text',
+            content: 'not-json',
+          },
+          sender: { sender_id: { open_id: 'ou_1' } },
+        },
+      };
+
+      const result = FeishuChannel.parseEventBody(body);
+      expect(result.content).toBe('not-json');
+    });
+  });
+
+  // ── Constructor ──────────────────────────────────
+
+  describe('constructor', () => {
+    it('should use defaults', () => {
+      const channel = new FeishuChannel();
+      expect(channel.type).toBe('feishu');
+    });
+
+    it('should accept config', () => {
+      const channel = new FeishuChannel({
+        appId: 'myapp',
+        appSecret: 'secret',
+        port: 9999,
+      });
+      expect(channel.type).toBe('feishu');
+    });
+  });
+});

package/tests/channels/telegram.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TelegramChannel } from '../../src/channels/telegram';
+
+describe('TelegramChannel', () => {
+  it('constructor sets token from config', () => {
+    const ch = new TelegramChannel({ token: 'test-token-123' });
+    expect((ch as any).token).toBe('test-token-123');
+  });
+
+  it('constructor defaults to polling mode', () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    expect((ch as any).mode).toBe('polling');
+  });
+
+  it('constructor reads token from env var', () => {
+    const orig = process.env.TELEGRAM_BOT_TOKEN;
+    process.env.TELEGRAM_BOT_TOKEN = 'env-token';
+    const ch = new TelegramChannel({});
+    expect((ch as any).token).toBe('env-token');
+    if (orig) process.env.TELEGRAM_BOT_TOKEN = orig;
+    else delete process.env.TELEGRAM_BOT_TOKEN;
+  });
+
+  it('constructor sets webhook mode', () => {
+    const ch = new TelegramChannel({ token: 'tok', mode: 'webhook', webhookUrl: 'https://x.com' });
+    expect((ch as any).mode).toBe('webhook');
+    expect((ch as any).webhookUrl).toBe('https://x.com');
+  });
+
+  it('constructor defaults port to 3001', () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    expect((ch as any).port).toBe(3001);
+  });
+
+  it('constructor uses custom port', () => {
+    const ch = new TelegramChannel({ token: 'tok', port: 8080 });
+    expect((ch as any).port).toBe(8080);
+  });
+
+  it('type is telegram', () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    expect(ch.type).toBe('telegram');
+  });
+
+  it('processUpdate extracts message text', async () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    const messages: any[] = [];
+    (ch as any).handler = async (msg: any) => { messages.push(msg); return { id: 'r', role: 'assistant', content: 'ok', timestamp: Date.now() }; };
+    // Mock sendMessage to avoid actual API call
+    (ch as any).sendMessage = vi.fn();
+    await (ch as any).processUpdate({
+      message: { message_id: 1, text: 'hello', date: 1000, chat: { id: 123 }, from: { id: 456, first_name: 'Test' } },
+    });
+    expect(messages).toHaveLength(1);
+    expect(messages[0].content).toBe('hello');
+  });
+
+  it('processUpdate handles edited_message', async () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    const messages: any[] = [];
+    (ch as any).handler = async (msg: any) => { messages.push(msg); return { id: 'r', role: 'assistant', content: 'ok', timestamp: Date.now() }; };
+    (ch as any).sendMessage = vi.fn();
+    await (ch as any).processUpdate({
+      edited_message: { message_id: 2, text: 'edited', date: 1000, chat: { id: 123 }, from: { id: 456, first_name: 'Test' } },
+    });
+    expect(messages).toHaveLength(1);
+    expect(messages[0].content).toBe('edited');
+  });
+
+  it('processUpdate ignores non-text updates', async () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    const messages: any[] = [];
+    ch.onMessage(async (msg) => { messages.push(msg); return { id: 'r', role: 'assistant', content: 'ok', timestamp: Date.now() } as any; });
+    (ch as any).sendMessage = vi.fn();
+    await (ch as any).processUpdate({
+      message: { message_id: 3, photo: [{}], date: 1000, chat: { id: 123 }, from: { id: 456 } },
+    });
+    expect(messages).toHaveLength(0);
+  });
+
+  it('processUpdate ignores update without handler', async () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    // Should not throw
+    await (ch as any).processUpdate({
+      message: { message_id: 4, text: 'hello', date: 1000, chat: { id: 123 }, from: { id: 456 } },
+    });
+  });
+
+  it('offset starts at 0', () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    expect((ch as any).offset).toBe(0);
+  });
+
+  it('missing token results in empty string', () => {
+    const orig = process.env.TELEGRAM_BOT_TOKEN;
+    delete process.env.TELEGRAM_BOT_TOKEN;
+    const ch = new TelegramChannel({});
+    expect((ch as any).token).toBe('');
+    if (orig) process.env.TELEGRAM_BOT_TOKEN = orig;
+  });
+
+  it('start with no token warns but does not throw', async () => {
+    const orig = process.env.TELEGRAM_BOT_TOKEN;
+    delete process.env.TELEGRAM_BOT_TOKEN;
+    const ch = new TelegramChannel({});
+    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await ch.start();
+    expect(spy).toHaveBeenCalled();
+    spy.mockRestore();
+    if (orig) process.env.TELEGRAM_BOT_TOKEN = orig;
+  });
+
+  it('sendMessage is a function', () => {
+    const ch = new TelegramChannel({ token: 'tok' });
+    expect(typeof (ch as any).sendMessage === 'function' || typeof (ch as any).apiCall === 'function').toBe(true);
+  });
+
+  it('long message chunking helper if available', () => {
+    // Test the concept - messages over 4096 chars should be split
+    const longText = 'a'.repeat(5000);
+    const chunks: string[] = [];
+    for (let i = 0; i < longText.length; i += 4096) {
+      chunks.push(longText.slice(i, i + 4096));
+    }
+    expect(chunks).toHaveLength(2);
+    expect(chunks[0].length).toBe(4096);
+    expect(chunks[1].length).toBe(904);
+  });
+});