@cnrai/pave 0.3.32 → 0.3.34

package/test/agent-inbox.test.js

@@ -0,0 +1,576 @@
+#!/usr/bin/env node
+/**
+ * Tests for agent inbox protocol (Issue #200)
+ *
+ * Verifies inbox message writing, draining, formatting, and
+ * args-parser support for -a/--agent flag.
+ *
+ * Designed to run standalone: node test/agent-inbox.test.js
+ * Imports modules directly (not mocked) for integration-level testing.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const registry = require('../lib/agent-registry');
+const parseArgs = require('../lib/args-parser').parseArgs;
+
+let passed = 0;
+let failed = 0;
+
+// Use temp dir for all tests
+const testDir = path.join(os.tmpdir(), 'agent-inbox-test-' + Date.now() + '-' + Math.random().toString(36).substr(2, 6));
+let canMkdir = false;
+try {
+  if (typeof fs.mkdirSync === 'function') {
+    fs.mkdirSync(testDir, { recursive: true });
+    canMkdir = true;
+  }
+} catch (e) {}
+if (canMkdir) registry.setAgentsDir(testDir);
+
+function assert(cond, msg) {
+  if (!cond) throw new Error(msg || 'assertion failed');
+}
+
+function runTest(name, fn) {
+  try {
+    fn();
+    console.log('[PASS] ' + name);
+    passed++;
+  } catch (e) {
+    console.log('[FAIL] ' + name + ': ' + e.message);
+    failed++;
+  }
+}
+
+function resetTestDir() {
+  if (!canMkdir) return;
+  try { fs.rmSync(testDir, { recursive: true, force: true }); } catch (e) {}
+  fs.mkdirSync(testDir, { recursive: true });
+}
+
+function cleanup() {
+  registry.resetAgentsDir();
+  try { fs.rmSync(testDir, { recursive: true, force: true }); } catch (e) {}
+}
+
+// ============================================================
+// getInboxDir
+// ============================================================
+
+runTest('getInboxDir returns correct path', () => {
+  const dir = registry.getInboxDir('my-agent');
+  assert(dir.indexOf('my-agent') !== -1, 'should contain agent name');
+  assert(dir.endsWith('inbox'), 'should end with inbox');
+});
+
+// ============================================================
+// writeInboxMessage
+// ============================================================
+
+resetTestDir();
+
+runTest('writeInboxMessage: writes a message file', () => {
+  const result = registry.writeInboxMessage('test-agent', 'hello world');
+  assert(result.success === true, 'should succeed');
+  assert(result.error === null, 'should have no error');
+  assert(result.file !== null, 'should return filename');
+  assert(result.file.endsWith('.json'), 'filename should end with .json');
+
+  // Verify file exists and is valid JSON
+  const inboxDir = registry.getInboxDir('test-agent');
+  const content = JSON.parse(fs.readFileSync(path.join(inboxDir, result.file), 'utf8'));
+  assert(content.message === 'hello world', 'message should match');
+  assert(content.from === 'tui', 'default from should be tui');
+  assert(content.priority === 'normal', 'default priority should be normal');
+  assert(typeof content.timestamp === 'number', 'should have timestamp');
+});
+
+runTest('writeInboxMessage: respects from and priority options', () => {
+  const result = registry.writeInboxMessage('test-agent', 'urgent task', {
+    from: 'code-reviewer',
+    priority: 'high',
+  });
+  assert(result.success === true, 'should succeed');
+
+  const inboxDir = registry.getInboxDir('test-agent');
+  const content = JSON.parse(fs.readFileSync(path.join(inboxDir, result.file), 'utf8'));
+  assert(content.from === 'code-reviewer', 'from should match');
+  assert(content.priority === 'high', 'priority should match');
+});
+
+runTest('writeInboxMessage: rejects empty message', () => {
+  const result = registry.writeInboxMessage('test-agent', '');
+  assert(result.success === false, 'should fail');
+  assert(result.error !== null, 'should have error');
+});
+
+runTest('writeInboxMessage: rejects non-string message', () => {
+  const result = registry.writeInboxMessage('test-agent', 123);
+  assert(result.success === false, 'should fail');
+  assert(result.error !== null, 'should have error');
+});
+
+runTest('writeInboxMessage: rejects invalid priority', () => {
+  const result = registry.writeInboxMessage('test-agent', 'test', { priority: 'critical' });
+  assert(result.success === false, 'should fail');
+  assert(result.error.indexOf('Invalid priority') !== -1, 'should mention invalid priority');
+});
+
+runTest('writeInboxMessage: sequence numbers increment', () => {
+  resetTestDir();
+  const r1 = registry.writeInboxMessage('seq-agent', 'msg 1');
+  const r2 = registry.writeInboxMessage('seq-agent', 'msg 2');
+  const r3 = registry.writeInboxMessage('seq-agent', 'msg 3');
+
+  assert(r1.success && r2.success && r3.success, 'all should succeed');
+
+  // Extract sequence numbers
+  const seq1 = parseInt(r1.file.split('-')[0], 10);
+  const seq2 = parseInt(r2.file.split('-')[0], 10);
+  const seq3 = parseInt(r3.file.split('-')[0], 10);
+
+  assert(seq1 < seq2, 'seq2 > seq1');
+  assert(seq2 < seq3, 'seq3 > seq2');
+});
+
+runTest('writeInboxMessage: filenames are zero-padded for FIFO sort', () => {
+  resetTestDir();
+  const r1 = registry.writeInboxMessage('pad-agent', 'msg');
+  assert(r1.file.match(/^\d{4}-/), 'filename should start with 4-digit zero-padded sequence');
+  // Filename should also include unique suffix: NNNN-<timestamp>-<pid>-<random>.json
+  assert(r1.file.match(/^\d{4}-\d+-\d+-[0-9a-f]+\.json$/), 'filename should match full pattern with unique suffix');
+});
+
+// ============================================================
+// inboxHasMessages
+// ============================================================
+
+resetTestDir();
+
+runTest('inboxHasMessages: false when no inbox directory', () => {
+  assert(registry.inboxHasMessages('nonexistent') === false, 'should be false');
+});
+
+runTest('inboxHasMessages: false when inbox is empty', () => {
+  const inboxDir = registry.getInboxDir('empty-agent');
+  fs.mkdirSync(inboxDir, { recursive: true });
+  assert(registry.inboxHasMessages('empty-agent') === false, 'should be false');
+});
+
+runTest('inboxHasMessages: true when messages exist', () => {
+  registry.writeInboxMessage('has-msg-agent', 'test');
+  assert(registry.inboxHasMessages('has-msg-agent') === true, 'should be true');
+});
+
+runTest('inboxHasMessages: ignores .tmp files', () => {
+  const inboxDir = registry.getInboxDir('tmp-agent');
+  fs.mkdirSync(inboxDir, { recursive: true });
+  fs.writeFileSync(path.join(inboxDir, '0001-123.json.tmp'), '{}');
+  assert(registry.inboxHasMessages('tmp-agent') === false, 'should be false (only .tmp files)');
+});
+
+// ============================================================
+// drainInbox
+// ============================================================
+
+resetTestDir();
+
+runTest('drainInbox: returns empty when no messages', () => {
+  const result = registry.drainInbox('no-inbox');
+  assert(result.messages.length === 0, 'should have no messages');
+  assert(result.remaining === 0, 'should have no remaining');
+});
+
+runTest('drainInbox: error path returns files array', () => {
+  // When inbox dir does not exist, drainInbox should return files: []
+  // so callers using result.files (e.g. deleteInboxFiles) don't crash
+  const result = registry.drainInbox('nonexistent-agent-xyz');
+  assert(Array.isArray(result.files), 'files should be an array, got: ' + typeof result.files);
+  assert(result.files.length === 0, 'files should be empty');
+  assert(result.messages.length === 0, 'messages should be empty');
+  assert(result.remaining === 0, 'remaining should be 0');
+});
+
+runTest('drainInbox: reads and deletes messages', () => {
+  resetTestDir();
+  registry.writeInboxMessage('drain-agent', 'msg 1');
+  registry.writeInboxMessage('drain-agent', 'msg 2');
+
+  const result = registry.drainInbox('drain-agent');
+  assert(result.messages.length === 2, 'should have 2 messages');
+  assert(result.remaining === 0, 'should have no remaining');
+
+  // Messages should be deleted
+  assert(registry.inboxHasMessages('drain-agent') === false, 'inbox should be empty after drain');
+});
+
+runTest('drainInbox: respects batch limit', () => {
+  resetTestDir();
+  for (let i = 0; i < 8; i++) {
+    registry.writeInboxMessage('limit-agent', 'msg ' + i);
+  }
+
+  const result = registry.drainInbox('limit-agent', { limit: 5 });
+  assert(result.messages.length === 5, 'should drain 5 messages');
+  assert(result.remaining === 3, 'should have 3 remaining');
+
+  // Remaining messages should still be in inbox
+  assert(registry.inboxHasMessages('limit-agent') === true, 'inbox should still have messages');
+});
+
+runTest('drainInbox: FIFO ordering by filename', () => {
+  resetTestDir();
+  registry.writeInboxMessage('fifo-agent', 'first');
+  registry.writeInboxMessage('fifo-agent', 'second');
+  registry.writeInboxMessage('fifo-agent', 'third');
+
+  const result = registry.drainInbox('fifo-agent');
+  // Within same priority, order should be FIFO
+  assert(result.messages[0].message === 'first', 'first message should be first');
+  assert(result.messages[1].message === 'second', 'second message should be second');
+  assert(result.messages[2].message === 'third', 'third message should be third');
+});
+
+runTest('drainInbox: high-priority messages sorted before normal', () => {
+  resetTestDir();
+  registry.writeInboxMessage('priority-agent', 'normal 1', { priority: 'normal' });
+  registry.writeInboxMessage('priority-agent', 'high 1', { priority: 'high' });
+  registry.writeInboxMessage('priority-agent', 'normal 2', { priority: 'normal' });
+  registry.writeInboxMessage('priority-agent', 'high 2', { priority: 'high' });
+
+  const result = registry.drainInbox('priority-agent');
+  assert(result.messages.length === 4, 'should have 4 messages');
+  assert(result.messages[0].priority === 'high', 'first should be high priority');
+  assert(result.messages[1].priority === 'high', 'second should be high priority');
+  assert(result.messages[2].priority === 'normal', 'third should be normal priority');
+  assert(result.messages[3].priority === 'normal', 'fourth should be normal priority');
+});
+
+runTest('drainInbox: handles malformed JSON gracefully', () => {
+  resetTestDir();
+  const inboxDir = registry.getInboxDir('malformed-agent');
+  fs.mkdirSync(inboxDir, { recursive: true });
+  fs.writeFileSync(path.join(inboxDir, '0001-1234.json'), 'not json');
+  registry.writeInboxMessage('malformed-agent', 'valid msg');
+
+  // Suppress console.error during this test
+  const origErr = console.error;
+  const errMessages = [];
+  console.error = function (msg) { errMessages.push(msg); };
+
+  const result = registry.drainInbox('malformed-agent');
+  console.error = origErr;
+
+  assert(result.messages.length === 1, 'should have 1 valid message');
+  assert(result.messages[0].message === 'valid msg', 'should be the valid message');
+  // Malformed file should be deleted
+  const remaining = fs.readdirSync(inboxDir).filter((f) => { return f.endsWith('.json'); });
+  assert(remaining.length === 0, 'malformed file should be deleted');
+});
+
+runTest('drainInbox: handles missing message field gracefully', () => {
+  resetTestDir();
+  const inboxDir = registry.getInboxDir('nomsg-agent');
+  fs.mkdirSync(inboxDir, { recursive: true });
+  fs.writeFileSync(path.join(inboxDir, '0001-1234.json'), JSON.stringify({ from: 'test' }));
+
+  const origErr = console.error;
+  console.error = function () {};
+  const result = registry.drainInbox('nomsg-agent');
+  console.error = origErr;
+
+  assert(result.messages.length === 0, 'should have 0 valid messages');
+});
+
+// ============================================================
+// formatInboxMessages
+// ============================================================
+
+runTest('formatInboxMessages: empty array returns empty string', () => {
+  assert(registry.formatInboxMessages([]) === '', 'should be empty');
+  assert(registry.formatInboxMessages(null) === '', 'null should be empty');
+});
+
+runTest('formatInboxMessages: formats single message', () => {
+  const formatted = registry.formatInboxMessages([
+    { message: 'hello', from: 'tui', priority: 'normal' },
+  ]);
+  assert(formatted.indexOf('You have received messages') !== -1, 'should have header');
+  assert(formatted.indexOf('[1]') !== -1, 'should have message number');
+  assert(formatted.indexOf('from: tui') !== -1, 'should show sender');
+  assert(formatted.indexOf('hello') !== -1, 'should contain message');
+  assert(formatted.indexOf('priority: high') === -1, 'should not show priority for normal');
+});
+
+runTest('formatInboxMessages: shows high priority tag', () => {
+  const formatted = registry.formatInboxMessages([
+    { message: 'urgent', from: 'admin', priority: 'high' },
+  ]);
+  assert(formatted.indexOf('priority: high') !== -1, 'should show priority for high');
+});
+
+runTest('formatInboxMessages: shows remaining count', () => {
+  const formatted = registry.formatInboxMessages([
+    { message: 'msg', from: 'tui', priority: 'normal' },
+  ], 3);
+  assert(formatted.indexOf('3 more messages remaining') !== -1, 'should show remaining');
+});
+
+runTest('formatInboxMessages: formats multiple messages', () => {
+  const formatted = registry.formatInboxMessages([
+    { message: 'first', from: 'tui', priority: 'normal' },
+    { message: 'second', from: 'bot', priority: 'high' },
+  ]);
+  assert(formatted.indexOf('[1]') !== -1, 'should have [1]');
+  assert(formatted.indexOf('[2]') !== -1, 'should have [2]');
+  assert(formatted.indexOf('first') !== -1, 'should have first message');
+  assert(formatted.indexOf('second') !== -1, 'should have second message');
+});
+
+// ============================================================
+// args-parser: -a / --agent flag
+// ============================================================
+
+runTest('args-parser: --agent flag for chat command', () => {
+  const result = parseArgs(['chat', '--agent', 'my-agent', 'hello world']);
+  assert(result.command === 'chat', 'command should be chat');
+  assert(result.agent === 'my-agent', 'agent should be my-agent');
+  assert(result.commandArgs.join(' ') === 'hello world', 'message should be preserved');
+});
+
+runTest('args-parser: -a shorthand for chat command', () => {
+  const result = parseArgs(['chat', '-a', 'my-agent', 'hello']);
+  assert(result.command === 'chat', 'command should be chat');
+  assert(result.agent === 'my-agent', 'agent should be my-agent');
+  assert(result.commandArgs.join(' ') === 'hello', 'message should be preserved');
+});
+
+runTest('args-parser: agent flag not set by default', () => {
+  const result = parseArgs(['chat', 'hello']);
+  assert(result.agent === null, 'agent should be null by default');
+});
+
+runTest('args-parser: --agent works with other chat flags', () => {
+  const result = parseArgs(['chat', '--agent', 'test', '--no-stream', 'my message']);
+  assert(result.agent === 'test', 'agent should be test');
+  assert(result.noStream === true, 'noStream should be true');
+  assert(result.commandArgs.join(' ') === 'my message', 'message should be preserved');
+});
+
+runTest('args-parser: --agent as global flag', () => {
+  const result = parseArgs(['chat', 'some message', '--agent', 'global-test']);
+  assert(result.agent === 'global-test', 'agent should be global-test');
+});
+
+runTest('args-parser: -a does not set --all for chat command', () => {
+  const result = parseArgs(['chat', '-a', 'my-agent', 'hello']);
+  assert(result.agent === 'my-agent', 'agent should be my-agent');
+  assert(!result.all, '-a should not set all=true for chat command');
+});
+
+runTest('args-parser: -a still sets --all for non-chat commands', () => {
+  const result = parseArgs(['search', '-a', 'keyword']);
+  assert(result.all === true, '-a should set all=true for search command');
+});
+
+// ============================================================
+// Numeric sort beyond zero-pad width
+// ============================================================
+
+resetTestDir();
+
+runTest('drainInbox: numeric sort handles sequences beyond zero-pad width', () => {
+  const inboxDir = registry.getInboxDir('bigsort-agent');
+  fs.mkdirSync(inboxDir, { recursive: true });
+  // Write files simulating sequences > 9999
+  fs.writeFileSync(path.join(inboxDir, '9999-1000-x.json'), JSON.stringify({ message: 'older', from: 'test', priority: 'normal', timestamp: 1000 }));
+  fs.writeFileSync(path.join(inboxDir, '10000-1001-x.json'), JSON.stringify({ message: 'newer', from: 'test', priority: 'normal', timestamp: 1001 }));
+
+  const result = registry.drainInbox('bigsort-agent');
+  assert(result.messages.length === 2, 'should have 2 messages');
+  assert(result.messages[0].message === 'older', '9999 should come before 10000');
+  assert(result.messages[1].message === 'newer', '10000 should come after 9999');
+});
+
+runTest('writeInboxMessage: concurrent writes produce unique filenames', () => {
+  resetTestDir();
+  // Write multiple messages rapidly - each should get unique filename
+  const results = [];
+  for (let i = 0; i < 10; i++) {
+    results.push(registry.writeInboxMessage('concurrent-agent', 'msg ' + i));
+  }
+
+  const filenames = new Set();
+  for (let j = 0; j < results.length; j++) {
+    assert(results[j].success, 'write ' + j + ' should succeed');
+    assert(!filenames.has(results[j].file), 'filename should be unique: ' + results[j].file);
+    filenames.add(results[j].file);
+  }
+  assert(filenames.size === 10, 'should have 10 unique filenames');
+});
+
+// ============================================================
+// Integration: write then drain
+// ============================================================
+
+resetTestDir();
+
+runTest('integration: write 3 messages then drain all', () => {
+  registry.writeInboxMessage('int-agent', 'msg 1');
+  registry.writeInboxMessage('int-agent', 'msg 2', { priority: 'high' });
+  registry.writeInboxMessage('int-agent', 'msg 3');
+
+  assert(registry.inboxHasMessages('int-agent') === true, 'should have messages');
+
+  const result = registry.drainInbox('int-agent');
+  assert(result.messages.length === 3, 'should have 3 messages');
+  assert(result.messages[0].priority === 'high', 'high priority should be first');
+  assert(result.remaining === 0, 'should have no remaining');
+
+  assert(registry.inboxHasMessages('int-agent') === false, 'inbox should be empty');
+
+  // Format for LLM
+  const formatted = registry.formatInboxMessages(result.messages, result.remaining);
+  assert(formatted.indexOf('You have received messages') !== -1, 'should have header');
+  assert(formatted.indexOf('[1]') !== -1, 'should have message 1');
+  assert(formatted.indexOf('[2]') !== -1, 'should have message 2');
+  assert(formatted.indexOf('[3]') !== -1, 'should have message 3');
+});
+
+runTest('integration: stopped agent still accepts messages', () => {
+  resetTestDir();
+  // Write status for a stopped agent
+  registry.writeStatus('stopped-agent', {
+    state: registry.STATES.STOPPED,
+    pid: 99999,
+    cwd: '/tmp',
+  });
+
+  // Should still be able to write to inbox
+  const result = registry.writeInboxMessage('stopped-agent', 'queued message');
+  assert(result.success === true, 'should succeed writing to stopped agent inbox');
+  assert(registry.inboxHasMessages('stopped-agent') === true, 'should have messages');
+});
+
+// ============================================================
+// Fix 2: --agent value validation (#231)
+// ============================================================
+
+runTest('args-parser: --agent rejects flag-like value in general parser', () => {
+  // In the general flag parser, --agent followed by a flag-like value
+  // does not set args.agent because of the !next.startsWith('-') guard.
+  // The chat-specific parser calls process.exit(1) which we can't test here.
+  // Test the general parser's behavior instead:
+  const result = parseArgs(['search', '--agent', '--verbose', 'keyword']);
+  assert(result.agent === null, 'agent should be null when followed by a flag: ' + result.agent);
+});
+
+runTest('args-parser: --agent accepts valid name', () => {
+  const result = parseArgs(['chat', '--agent', 'my-agent', 'hello']);
+  assert(result.agent === 'my-agent', 'agent should be my-agent');
+});
+
+runTest('args-parser: chat --agent with flag-like value exits with code 1', () => {
+  const cp = require('child_process');
+  const tmpDir = path.join(os.tmpdir(), 'pave-test-agent-exit-' + process.pid + '-' + Date.now());
+  fs.mkdirSync(tmpDir, { recursive: true });
+  const result = cp.spawnSync(
+    process.execPath,
+    [path.join(__dirname, '..', 'index.js'), 'chat', '--agent', '--no-stream'],
+    { timeout: 5000, encoding: 'utf8', cwd: tmpDir, env: { ...process.env, HOME: tmpDir, NO_COLOR: '1' } },
+  );
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (e) {}
+  assert(result.status === 1, 'should exit with code 1, got: ' + result.status);
+});
+
+runTest('args-parser: chat --agent with missing value exits with code 1', () => {
+  const cp = require('child_process');
+  const tmpDir = path.join(os.tmpdir(), 'pave-test-agent-exit-' + process.pid + '-' + Date.now());
+  fs.mkdirSync(tmpDir, { recursive: true });
+  const result = cp.spawnSync(
+    process.execPath,
+    [path.join(__dirname, '..', 'index.js'), 'chat', '--agent'],
+    { timeout: 5000, encoding: 'utf8', cwd: tmpDir, env: { ...process.env, HOME: tmpDir, NO_COLOR: '1' } },
+  );
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (e) {}
+  assert(result.status === 1, 'should exit with code 1, got: ' + result.status);
+});
+
+// ============================================================
+// Fix 3: drainInbox deferred deletion (#231)
+// ============================================================
+
+resetTestDir();
+
+runTest('drainInbox: deleteFiles=false preserves files on disk', () => {
+  resetTestDir();
+  registry.writeInboxMessage('defer-agent', 'msg1');
+  registry.writeInboxMessage('defer-agent', 'msg2');
+
+  const result = registry.drainInbox('defer-agent', { deleteFiles: false });
+  assert(result.messages.length === 2, 'should read 2 messages');
+  assert(Array.isArray(result.files), 'should return files array');
+  assert(result.files.length === 2, 'should have 2 file paths');
+
+  // Files should still exist
+  assert(registry.inboxHasMessages('defer-agent'), 'inbox should still have messages');
+});
+
+runTest('drainInbox: default behavior still deletes files', () => {
+  resetTestDir();
+  registry.writeInboxMessage('default-agent', 'msg1');
+
+  const result = registry.drainInbox('default-agent');
+  assert(result.messages.length === 1, 'should read 1 message');
+  assert(!registry.inboxHasMessages('default-agent'), 'inbox should be empty after default drain');
+});
+
+runTest('deleteInboxFiles: removes specified files', () => {
+  resetTestDir();
+  registry.writeInboxMessage('delete-agent', 'msg1');
+  registry.writeInboxMessage('delete-agent', 'msg2');
+
+  const result = registry.drainInbox('delete-agent', { deleteFiles: false });
+  assert(registry.inboxHasMessages('delete-agent'), 'files should exist before delete');
+
+  registry.deleteInboxFiles(result.files);
+  assert(!registry.inboxHasMessages('delete-agent'), 'files should be gone after deleteInboxFiles');
+});
+
+runTest('deleteInboxFiles: handles null/undefined gracefully', () => {
+  // Should not throw
+  registry.deleteInboxFiles(null);
+  registry.deleteInboxFiles(undefined);
+  registry.deleteInboxFiles([]);
+});
+
+runTest('drainInbox: files array contains absolute paths', () => {
+  resetTestDir();
+  registry.writeInboxMessage('path-agent', 'msg1');
+
+  const result = registry.drainInbox('path-agent', { deleteFiles: false });
+  assert(result.files.length === 1, 'should have 1 file');
+  assert(path.isAbsolute(result.files[0]), 'file path should be absolute: ' + result.files[0]);
+
+  // Cleanup
+  registry.deleteInboxFiles(result.files);
+});
+
+// ============================================================
+// Cleanup
+// ============================================================
+
+cleanup();
+
+// ============================================================
+// Summary
+// ============================================================
+
+console.log('');
+console.log('Total: ' + (passed + failed) + ', Passed: ' + passed + ', Failed: ' + failed);
+if (failed > 0) {
+  process.exitCode = 1;
+}