opc-agent 1.4.0 → 2.0.1

package/tests/channels/websocket.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { WebSocketChannel } from '../../src/channels/websocket';
+
+// We can't easily test WebSocket server without starting it, 
+// but we can test the room management and config logic.
+
+describe('WebSocketChannel', () => {
+  describe('constructor', () => {
+    it('should accept port number', () => {
+      const channel = new WebSocketChannel(4000);
+      expect(channel.type).toBe('websocket');
+    });
+
+    it('should accept config object', () => {
+      const channel = new WebSocketChannel({
+        port: 4000,
+        heartbeatInterval: 15000,
+        authTokens: ['secret'],
+        maxClientsPerRoom: 50,
+      });
+      expect(channel.type).toBe('websocket');
+    });
+
+    it('should use defaults', () => {
+      const channel = new WebSocketChannel();
+      expect(channel.type).toBe('websocket');
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return empty stats initially', () => {
+      const channel = new WebSocketChannel(4001);
+      const stats = channel.getStats();
+      expect(stats.clients).toBe(0);
+      expect(stats.rooms).toBe(0);
+      expect(stats.roomDetails).toEqual({});
+    });
+  });
+
+  describe('getRooms', () => {
+    it('should return empty array initially', () => {
+      const channel = new WebSocketChannel(4002);
+      expect(channel.getRooms()).toEqual([]);
+    });
+  });
+
+  describe('getRoomMembers', () => {
+    it('should return empty for non-existent room', () => {
+      const channel = new WebSocketChannel(4003);
+      expect(channel.getRoomMembers('nonexistent')).toEqual([]);
+    });
+  });
+});

package/tests/channels/wechat.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect } from 'vitest';
+import { WeChatChannel } from '../../src/channels/wechat';
+import * as crypto from 'crypto';
+
+describe('WeChatChannel', () => {
+  // ── XML Parsing ──────────────────────────────────
+
+  describe('parseXML', () => {
+    it('should parse text message XML', () => {
+      const xml = `<xml>
+        <ToUserName><![CDATA[gh_123456]]></ToUserName>
+        <FromUserName><![CDATA[oUser123]]></FromUserName>
+        <CreateTime>1348831860</CreateTime>
+        <MsgType><![CDATA[text]]></MsgType>
+        <Content><![CDATA[Hello World]]></Content>
+        <MsgId>1234567890123456</MsgId>
+      </xml>`;
+
+      const msg = WeChatChannel.parseXML(xml);
+      expect(msg).not.toBeNull();
+      expect(msg!.toUserName).toBe('gh_123456');
+      expect(msg!.fromUserName).toBe('oUser123');
+      expect(msg!.createTime).toBe(1348831860);
+      expect(msg!.msgType).toBe('text');
+      expect(msg!.content).toBe('Hello World');
+      expect(msg!.msgId).toBe('1234567890123456');
+    });
+
+    it('should parse event message XML (subscribe)', () => {
+      const xml = `<xml>
+        <ToUserName><![CDATA[gh_123456]]></ToUserName>
+        <FromUserName><![CDATA[oUser123]]></FromUserName>
+        <CreateTime>1348831860</CreateTime>
+        <MsgType><![CDATA[event]]></MsgType>
+        <Event><![CDATA[subscribe]]></Event>
+      </xml>`;
+
+      const msg = WeChatChannel.parseXML(xml);
+      expect(msg).not.toBeNull();
+      expect(msg!.msgType).toBe('event');
+      expect(msg!.event).toBe('subscribe');
+    });
+
+    it('should parse image message XML', () => {
+      const xml = `<xml>
+        <ToUserName><![CDATA[gh_123456]]></ToUserName>
+        <FromUserName><![CDATA[oUser123]]></FromUserName>
+        <CreateTime>1348831860</CreateTime>
+        <MsgType><![CDATA[image]]></MsgType>
+        <MsgId>1234567890123456</MsgId>
+      </xml>`;
+
+      const msg = WeChatChannel.parseXML(xml);
+      expect(msg).not.toBeNull();
+      expect(msg!.msgType).toBe('image');
+    });
+
+    it('should return null for invalid XML', () => {
+      expect(WeChatChannel.parseXML('')).toBeNull();
+      expect(WeChatChannel.parseXML('not xml')).toBeNull();
+      expect(WeChatChannel.parseXML('<xml></xml>')).toBeNull();
+    });
+
+    it('should handle XML with plain text (no CDATA)', () => {
+      const xml = `<xml>
+        <ToUserName>gh_123456</ToUserName>
+        <FromUserName>oUser123</FromUserName>
+        <CreateTime>1348831860</CreateTime>
+        <MsgType>text</MsgType>
+        <Content>Hello</Content>
+      </xml>`;
+
+      const msg = WeChatChannel.parseXML(xml);
+      expect(msg).not.toBeNull();
+      expect(msg!.content).toBe('Hello');
+    });
+  });
+
+  // ── XML Response Formatting ──────────────────────
+
+  describe('formatXMLResponse', () => {
+    it('should format valid XML response', () => {
+      const xml = WeChatChannel.formatXMLResponse('oUser123', 'gh_123456', 'Hello!');
+      expect(xml).toContain('<ToUserName><![CDATA[oUser123]]></ToUserName>');
+      expect(xml).toContain('<FromUserName><![CDATA[gh_123456]]></FromUserName>');
+      expect(xml).toContain('<Content><![CDATA[Hello!]]></Content>');
+      expect(xml).toContain('<MsgType><![CDATA[text]]></MsgType>');
+      expect(xml).toContain('<CreateTime>');
+    });
+
+    it('should handle special characters in content', () => {
+      const xml = WeChatChannel.formatXMLResponse('u', 'g', 'Hello <world> & "friends"');
+      expect(xml).toContain('Hello <world> & "friends"');
+    });
+  });
+
+  // ── Signature Verification ───────────────────────
+
+  describe('verifySignature', () => {
+    it('should verify valid signature', () => {
+      const token = 'mytoken123';
+      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token });
+
+      const timestamp = '1348831860';
+      const nonce = 'abc123';
+      const arr = [token, timestamp, nonce].sort();
+      const expectedSignature = crypto.createHash('sha1').update(arr.join('')).digest('hex');
+
+      expect(channel.verifySignature(expectedSignature, timestamp, nonce)).toBe(true);
+    });
+
+    it('should reject invalid signature', () => {
+      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'mytoken' });
+      expect(channel.verifySignature('invalidsig', '123', 'abc')).toBe(false);
+    });
+
+    it('should handle empty inputs', () => {
+      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'tok' });
+      expect(channel.verifySignature('', '', '')).toBe(false);
+    });
+  });
+
+  // ── Message Handling ─────────────────────────────
+
+  describe('handleMessage', () => {
+    it('should handle subscribe event', async () => {
+      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'tok' });
+      const result = await channel.handleMessage({
+        toUserName: 'gh_123',
+        fromUserName: 'oUser',
+        createTime: 1000,
+        msgType: 'event',
+        event: 'subscribe',
+      });
+      expect(result).toContain('Welcome');
+    });
+
+    it('should handle text message with handler', async () => {
+      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'tok' });
+      channel.onMessage(async (msg) => ({
+        id: 'reply',
+        role: 'assistant',
+        content: `Echo: ${msg.content}`,
+        timestamp: Date.now(),
+      }));
+
+      const result = await channel.handleMessage({
+        toUserName: 'gh_123',
+        fromUserName: 'oUser',
+        createTime: 1000,
+        msgType: 'text',
+        content: 'Hello',
+        msgId: 'msg1',
+      });
+      expect(result).toBe('Echo: Hello');
+    });
+
+    it('should return empty for text message without handler', async () => {
+      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'tok' });
+      const result = await channel.handleMessage({
+        toUserName: 'gh_123',
+        fromUserName: 'oUser',
+        createTime: 1000,
+        msgType: 'text',
+        content: 'Hello',
+      });
+      expect(result).toBe('');
+    });
+  });
+});

package/tests/chat-cli.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, vi } from 'vitest';
+
+/**
+ * Tests for CLI chat slash command handling logic.
+ * We test the command parsing logic directly since the chat command
+ * is tightly coupled to readline/process.
+ */
+
+// Extract the slash command logic for testing
+function createSlashHandler(options: {
+  agentName?: string;
+  agentVersion?: string;
+  providerName?: string;
+  model?: string;
+  skillNames?: string[];
+  history?: { role: string; content: string }[];
+}) {
+  const {
+    agentName = 'test-agent',
+    agentVersion = '1.0.0',
+    providerName = 'openai',
+    model = 'gpt-4',
+    skillNames = [],
+    history = [],
+  } = options;
+
+  const output: string[] = [];
+  const log = (msg: string) => output.push(msg);
+
+  const handleSlashCommand = (cmd: string): boolean => {
+    const lower = cmd.toLowerCase().trim();
+    if (lower === '/quit' || lower === '/exit') {
+      output.push('QUIT');
+      return true;
+    }
+    if (lower === '/help') {
+      log('Available commands:');
+      log('/help /quit /clear /skills /memory /info');
+      return true;
+    }
+    if (lower === '/clear') {
+      history.length = 0;
+      log('Conversation history cleared.');
+      return true;
+    }
+    if (lower === '/skills') {
+      if (skillNames.length === 0) {
+        log('No skills registered.');
+      } else {
+        log('Registered skills:');
+        skillNames.forEach(s => log(`• ${s}`));
+      }
+      return true;
+    }
+    if (lower === '/info') {
+      log(`Name: ${agentName}`);
+      log(`Version: ${agentVersion}`);
+      log(`Provider: ${providerName}`);
+      log(`Model: ${model}`);
+      return true;
+    }
+    return false;
+  };
+
+  return { handleSlashCommand, output, history };
+}
+
+describe('Chat CLI slash commands', () => {
+  it('/help returns command list', () => {
+    const { handleSlashCommand, output } = createSlashHandler({});
+    const handled = handleSlashCommand('/help');
+    expect(handled).toBe(true);
+    expect(output.some(l => l.includes('commands'))).toBe(true);
+  });
+
+  it('/clear resets history', () => {
+    const history = [{ role: 'user', content: 'hi' }, { role: 'assistant', content: 'hello' }];
+    const { handleSlashCommand } = createSlashHandler({ history });
+    handleSlashCommand('/clear');
+    expect(history).toHaveLength(0);
+  });
+
+  it('/skills lists skills', () => {
+    const { handleSlashCommand, output } = createSlashHandler({ skillNames: ['echo', 'search'] });
+    handleSlashCommand('/skills');
+    expect(output.some(l => l.includes('echo'))).toBe(true);
+    expect(output.some(l => l.includes('search'))).toBe(true);
+  });
+
+  it('/skills with no skills shows empty message', () => {
+    const { handleSlashCommand, output } = createSlashHandler({ skillNames: [] });
+    handleSlashCommand('/skills');
+    expect(output.some(l => l.includes('No skills'))).toBe(true);
+  });
+
+  it('/info shows agent info', () => {
+    const { handleSlashCommand, output } = createSlashHandler({ agentName: 'MyBot', model: 'gpt-4o' });
+    handleSlashCommand('/info');
+    expect(output.some(l => l.includes('MyBot'))).toBe(true);
+    expect(output.some(l => l.includes('gpt-4o'))).toBe(true);
+  });
+
+  it('/quit sets quit flag', () => {
+    const { handleSlashCommand, output } = createSlashHandler({});
+    handleSlashCommand('/quit');
+    expect(output).toContain('QUIT');
+  });
+
+  it('/exit also works as quit', () => {
+    const { handleSlashCommand, output } = createSlashHandler({});
+    handleSlashCommand('/exit');
+    expect(output).toContain('QUIT');
+  });
+
+  it('unknown slash command returns false', () => {
+    const { handleSlashCommand } = createSlashHandler({});
+    expect(handleSlashCommand('/unknown')).toBe(false);
+  });
+
+  it('non-slash text returns false', () => {
+    const { handleSlashCommand } = createSlashHandler({});
+    expect(handleSlashCommand('hello world')).toBe(false);
+  });
+
+  it('case insensitive: /HELP works', () => {
+    const { handleSlashCommand, output } = createSlashHandler({});
+    expect(handleSlashCommand('/HELP')).toBe(true);
+    expect(output.length).toBeGreaterThan(0);
+  });
+
+  it('whitespace trimmed: "  /help  " works', () => {
+    const { handleSlashCommand, output } = createSlashHandler({});
+    expect(handleSlashCommand('  /help  ')).toBe(true);
+  });
+
+  it('empty input handling', () => {
+    const text = '   '.trim();
+    expect(text).toBe('');
+    // Empty input should be skipped (no slash command)
+  });
+
+  it('banner would contain agent name', () => {
+    const agentName = 'MyTestAgent';
+    const banner = `OPC Agent - Interactive Chat - ${agentName}`;
+    expect(banner).toContain(agentName);
+  });
+
+  it('/clear then history is empty', () => {
+    const history = [{ role: 'user', content: 'msg1' }];
+    const { handleSlashCommand } = createSlashHandler({ history });
+    expect(history).toHaveLength(1);
+    handleSlashCommand('/clear');
+    expect(history).toHaveLength(0);
+  });
+
+  it('message without slash goes to agent (not handled by slash handler)', () => {
+    const { handleSlashCommand } = createSlashHandler({});
+    expect(handleSlashCommand('tell me a joke')).toBe(false);
+  });
+});

package/tests/cli.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('CLI: opc chat slash commands', () => {
+  // Test that slash commands are recognized patterns
+  const slashCommands = ['/help', '/quit', '/exit', '/clear', '/skills', '/memory', '/info'];
+
+  it('should define all expected slash commands', () => {
+    const cliSource = fs.readFileSync(path.join(__dirname, '..', 'src', 'cli.ts'), 'utf-8');
+    for (const cmd of slashCommands) {
+      expect(cliSource).toContain(`'${cmd}'`);
+    }
+  });
+
+  it('chat command should be registered', () => {
+    const cliSource = fs.readFileSync(path.join(__dirname, '..', 'src', 'cli.ts'), 'utf-8');
+    expect(cliSource).toContain(".command('chat')");
+    expect(cliSource).toContain('Interactive CLI chat with the agent');
+  });
+
+  it('init command should generate SOUL.md and CONTEXT.md', () => {
+    const cliSource = fs.readFileSync(path.join(__dirname, '..', 'src', 'cli.ts'), 'utf-8');
+    expect(cliSource).toContain("'SOUL.md'");
+    expect(cliSource).toContain("'CONTEXT.md'");
+    expect(cliSource).toContain('# Project Context');
+    expect(cliSource).toContain('Personality');
+  });
+
+  it('chat banner should include expected elements', () => {
+    const cliSource = fs.readFileSync(path.join(__dirname, '..', 'src', 'cli.ts'), 'utf-8');
+    expect(cliSource).toContain('OPC Agent — Interactive Chat');
+    expect(cliSource).toContain('/help for commands');
+    expect(cliSource).toContain('╔');
+    expect(cliSource).toContain('╚');
+  });
+
+  it('chat should load SOUL.md and CONTEXT.md', () => {
+    const cliSource = fs.readFileSync(path.join(__dirname, '..', 'src', 'cli.ts'), 'utf-8');
+    expect(cliSource).toContain("'SOUL.md'");
+    expect(cliSource).toContain("'CONTEXT.md'");
+    // Should prepend to system prompt
+    expect(cliSource).toContain('soulContent');
+    expect(cliSource).toContain('contextContent');
+  });
+});

package/tests/daemon.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('Daemon', () => {
+  const OPC_DIR_NAME = '.opc';
+  let tmpDir: string;
+  let opcDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'daemon-test-'));
+    opcDir = path.join(tmpDir, OPC_DIR_NAME);
+    fs.mkdirSync(opcDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // Test the daemon's file-based contract (PID, heartbeat, log)
+  it('PID file can be created', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, '12345');
+    expect(fs.existsSync(pidFile)).toBe(true);
+    expect(fs.readFileSync(pidFile, 'utf-8')).toBe('12345');
+  });
+
+  it('PID file can be removed', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, '12345');
+    fs.unlinkSync(pidFile);
+    expect(fs.existsSync(pidFile)).toBe(false);
+  });
+
+  it('status: PID exists and process alive → running', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, String(process.pid)); // current process is alive
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8'));
+    let alive = false;
+    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
+    expect(alive).toBe(true);
+  });
+
+  it('status: no PID file → stopped', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    expect(fs.existsSync(pidFile)).toBe(false);
+  });
+
+  it('stale PID detection: PID file with non-running process', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, '999999999'); // very unlikely to be running
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8'));
+    let alive = false;
+    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
+    expect(alive).toBe(false);
+  });
+
+  it('heartbeat file written', () => {
+    const hbFile = path.join(opcDir, 'heartbeat');
+    const now = String(Date.now());
+    fs.writeFileSync(hbFile, now);
+    expect(fs.readFileSync(hbFile, 'utf-8')).toBe(now);
+  });
+
+  it('heartbeat staleness detection', () => {
+    const hbFile = path.join(opcDir, 'heartbeat');
+    const old = String(Date.now() - 120_000); // 2 minutes ago
+    fs.writeFileSync(hbFile, old);
+    const hbTime = parseInt(fs.readFileSync(hbFile, 'utf-8'));
+    expect(Date.now() - hbTime).toBeGreaterThan(60_000);
+  });
+
+  it('log file created', () => {
+    const logFile = path.join(opcDir, 'agent.log');
+    fs.writeFileSync(logFile, '[2026-04-18T10:00:00.000Z] Daemon started\n');
+    expect(fs.existsSync(logFile)).toBe(true);
+  });
+
+  it('log file appendable', () => {
+    const logFile = path.join(opcDir, 'agent.log');
+    fs.writeFileSync(logFile, 'line1\n');
+    fs.appendFileSync(logFile, 'line2\n');
+    const content = fs.readFileSync(logFile, 'utf-8');
+    expect(content).toContain('line1');
+    expect(content).toContain('line2');
+  });
+
+  it('double-start prevention: PID file already exists', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, String(process.pid));
+    // Simulating: check before starting
+    const exists = fs.existsSync(pidFile);
+    expect(exists).toBe(true);
+    // A real daemon would check and abort
+  });
+
+  it('started file tracks uptime', () => {
+    const startedFile = path.join(opcDir, 'started');
+    const startTime = Date.now();
+    fs.writeFileSync(startedFile, String(startTime));
+    const uptime = Date.now() - parseInt(fs.readFileSync(startedFile, 'utf-8'));
+    expect(uptime).toBeGreaterThanOrEqual(0);
+    expect(uptime).toBeLessThan(1000);
+  });
+
+  it('.opc directory creation is idempotent', () => {
+    fs.mkdirSync(opcDir, { recursive: true });
+    fs.mkdirSync(opcDir, { recursive: true }); // should not throw
+    expect(fs.existsSync(opcDir)).toBe(true);
+  });
+
+  it('graceful shutdown cleans up PID file', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, '12345');
+    // Simulate shutdown
+    try { fs.unlinkSync(pidFile); } catch { /* ignore */ }
+    expect(fs.existsSync(pidFile)).toBe(false);
+  });
+
+  it('env file parsing', () => {
+    const envFile = path.join(tmpDir, '.env');
+    fs.writeFileSync(envFile, 'KEY1=value1\nKEY2=value2\n# comment\n');
+    const content = fs.readFileSync(envFile, 'utf-8');
+    const vars: Record<string, string> = {};
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      const eqIdx = trimmed.indexOf('=');
+      if (eqIdx === -1) continue;
+      vars[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim();
+    }
+    expect(vars).toEqual({ KEY1: 'value1', KEY2: 'value2' });
+  });
+});