@cnrai/pave 0.3.33 → 0.3.35

package/test/integration.test.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Integration test for tool output display functionality
+ * Tests the end-to-end behavior of the chat command with tool flags
+ * Run with: node test/integration.test.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function runTest(name, testFn) {
+  try {
+    testFn();
+    console.log(`✅ ${name}`);
+  } catch (error) {
+    console.log(`❌ ${name}: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(`${message}: expected ${expected}, got ${actual}`);
+  }
+}
+
+// Test help text includes --no-tools flag
+runTest('Help text should include --no-tools flag', () => {
+  const { showHelp } = require('../lib/args-parser');
+
+  // Capture help output
+  let helpOutput = '';
+  const originalConsoleLog = console.log;
+  console.log = (msg) => { helpOutput += msg + '\n'; };
+
+  try {
+    showHelp();
+  } finally {
+    console.log = originalConsoleLog;
+  }
+
+  assertEqual(helpOutput.includes('--no-tools'), true, 'Help should mention --no-tools flag');
+});
+
+// Test the main index.js can be loaded without errors
+runTest('Main index.js should load without syntax errors', () => {
+  const indexPath = path.join(__dirname, '..', 'index.js');
+  assertEqual(fs.existsSync(indexPath), true, 'index.js should exist');
+
+  // Check that handleChatCommand function includes showTools parameter
+  const indexContent = fs.readFileSync(indexPath, 'utf8');
+  assertEqual(indexContent.includes('showTools'), true, 'index.js should reference showTools');
+});
+
+// Test sendMessageAndStream function signature
+runTest('sendMessageAndStream should accept showTools option', () => {
+  const indexPath = path.join(__dirname, '..', 'index.js');
+  const indexContent = fs.readFileSync(indexPath, 'utf8');
+
+  // Check that showTools is passed to sendMessageAndStream
+  assertEqual(indexContent.includes('showTools'), true, 'Should reference showTools parameter');
+});
+
+// Test args-parser.js has correct defaults (showTools defaults to true)
+runTest('args-parser should have correct default values', () => {
+  const argsPath = path.join(__dirname, '..', 'lib', 'args-parser.js');
+  const argsContent = fs.readFileSync(argsPath, 'utf8');
+
+  assertEqual(argsContent.includes('showTools: true'), true, 'Default showTools should be true');
+});
+
+// Test flag parsing logic
+runTest('Flag parsing should handle --no-tools in chat command args', () => {
+  const argsPath = path.join(__dirname, '..', 'lib', 'args-parser.js');
+  const argsContent = fs.readFileSync(argsPath, 'utf8');
+
+  // Check that --no-tools is recognized
+  assertEqual(argsContent.includes('--no-tools'), true, 'Should recognize --no-tools flag');
+});
+
+console.log('\n🔍 Integration Test Summary:');
+if (process.exitCode === 1) {
+  console.log('Some integration tests failed. The changes may not be properly integrated.');
+} else {
+  console.log('All integration tests passed! The tool output functionality is properly integrated. 🎉');
+}

package/test/memory-guard-env.test.js

@@ -0,0 +1,220 @@
+/**
+ * Tests for Memory Guard env variable override bug (issue #268)
+ *
+ * Bug 1: startupLimits are hardcoded — env vars only apply to normalLimits
+ * Bug 2: setStartupMode(false) is never called on non-iSH (macOS)
+ *
+ * Tests verify the fixes via static analysis of the source files.
+ */
+
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+// Read source files for static analysis
+const guardSource = fs.readFileSync(
+  path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'utils', 'memory-guard.js'),
+  'utf8',
+);
+const paveSource = fs.readFileSync(
+  path.join(__dirname, '..', 'index.js'),
+  'utf8',
+);
+
+let passed = 0;
+let failed = 0;
+let total = 0;
+
+function runTest(name, fn) {
+  total++;
+  try {
+    fn();
+    console.log('\u2705 ' + name);
+    passed++;
+  } catch (e) {
+    console.log('\u274c ' + name + ': ' + e.message);
+    failed++;
+  }
+}
+
+function assertContains(src, needle, msg) {
+  assert(src.indexOf(needle) !== -1, (msg || '') + ' — missing: "' + needle + '"');
+}
+
+function assertNotContains(src, needle, msg) {
+  assert(src.indexOf(needle) === -1, (msg || '') + ' — found: "' + needle + '"');
+}
+
+// =============================================================
+// 1. Bug 1: startupLimits respect env overrides
+// =============================================================
+
+// Helper: split startupLimits ternary into iSH and non-iSH branches
+function getStartupBranches() {
+  const startupIdx = guardSource.indexOf('this.startupLimits');
+  assert(startupIdx !== -1, 'should have startupLimits definition');
+  const startupBlock = guardSource.substring(startupIdx, startupIdx + 900);
+  const parts = startupBlock.split('} : {');
+  assert(parts.length >= 2, 'startupLimits should contain a ternary with "} : {"');
+  return { ish: parts[0], nonIsh: parts[1], full: startupBlock };
+}
+
+runTest('startupLimits non-iSH heapUsed uses ENV_HEAP_LIMIT via Math.max', () => {
+  const branches = getStartupBranches();
+  assertContains(branches.nonIsh, 'Math.max(ENV_HEAP_LIMIT',
+    'non-iSH startupLimits heapUsed should use Math.max with ENV_HEAP_LIMIT');
+});
+
+runTest('startupLimits non-iSH critical uses ENV_CRITICAL_LIMIT via Math.max', () => {
+  const branches = getStartupBranches();
+  assertContains(branches.nonIsh, 'Math.max(ENV_CRITICAL_LIMIT',
+    'non-iSH startupLimits critical should use Math.max with ENV_CRITICAL_LIMIT');
+});
+
+runTest('startupLimits iSH heapUsed also uses ENV_HEAP_LIMIT via Math.max', () => {
+  const branches = getStartupBranches();
+  assertContains(branches.ish, 'Math.max(ENV_HEAP_LIMIT',
+    'iSH startupLimits should also use ENV_HEAP_LIMIT');
+});
+
+runTest('startupLimits iSH critical also uses ENV_CRITICAL_LIMIT via Math.max', () => {
+  const branches = getStartupBranches();
+  assertContains(branches.ish, 'Math.max(ENV_CRITICAL_LIMIT',
+    'iSH startupLimits critical should also use ENV_CRITICAL_LIMIT');
+});
+
+runTest('startupLimits comment references issue #268', () => {
+  const startupIdx = guardSource.indexOf('this.startupLimits');
+  const commentRegion = guardSource.substring(startupIdx - 200, startupIdx + 50);
+  assertContains(commentRegion, '#268',
+    'startupLimits fix should reference issue #268');
+});
+
+runTest('normalLimits still use ENV overrides (unchanged)', () => {
+  const normalIdx = guardSource.indexOf('this.normalLimits');
+  const normalBlock = guardSource.substring(normalIdx, normalIdx + 600);
+  assertContains(normalBlock, 'ENV_HEAP_LIMIT ||',
+    'normalLimits should still use ENV_HEAP_LIMIT');
+  assertContains(normalBlock, 'ENV_CRITICAL_LIMIT ||',
+    'normalLimits should still use ENV_CRITICAL_LIMIT');
+});
+
+// =============================================================
+// 2. Bug 2: setStartupMode(false) called on ALL platforms
+// =============================================================
+
+runTest('notifySessionActivated calls setStartupMode(false) without isISH gate', () => {
+  const fnIdx = guardSource.indexOf('function notifySessionActivated');
+  assert(fnIdx !== -1, 'should have notifySessionActivated function');
+  const fnBody = guardSource.substring(fnIdx, fnIdx + 600);
+  assertContains(fnBody, 'guard.setStartupMode(false)',
+    'should call setStartupMode(false)');
+  // Verify no isISH gate: the pattern "if (guard.isISH)" should not appear
+  // (guard.isISH may appear in comments explaining the fix, which is fine)
+  assertNotContains(fnBody, 'if (guard.isISH)',
+    'should NOT gate setStartupMode(false) behind if (guard.isISH)');
+});
+
+runTest('notifySessionActivated fix references issue #268', () => {
+  const fnIdx = guardSource.indexOf('function notifySessionActivated');
+  const fnBody = guardSource.substring(fnIdx, fnIdx + 600);
+  assertContains(fnBody, '#268',
+    'notifySessionActivated fix should reference issue #268');
+});
+
+// =============================================================
+// 3. Bug 2 part 2: index.js setStartupMode(true) on ALL platforms
+// =============================================================
+
+runTest('index.js setStartupMode(true) is NOT gated behind isISH', () => {
+  const startupIdx = paveSource.indexOf('.setStartupMode(true)');
+  assert(startupIdx !== -1, 'should have setStartupMode(true) call');
+  // Check the surrounding region — should NOT have 'if (isISH)' guard
+  const surroundingBefore = paveSource.substring(startupIdx - 300, startupIdx);
+  assertNotContains(surroundingBefore, 'if (isISH)',
+    'setStartupMode(true) should NOT be gated behind if (isISH)');
+});
+
+runTest('index.js setStartupMode block references issue #268', () => {
+  const startupIdx = paveSource.indexOf('.setStartupMode(true)');
+  const commentRegion = paveSource.substring(startupIdx - 300, startupIdx);
+  assertContains(commentRegion, '#268',
+    'index.js startup mode fix should reference issue #268');
+});
+
+runTest('index.js setStartupMode block mentions ALL platforms', () => {
+  const startupIdx = paveSource.indexOf('.setStartupMode(true)');
+  const commentRegion = paveSource.substring(startupIdx - 400, startupIdx);
+  // Should mention that it runs on all platforms now
+  assert(
+    commentRegion.indexOf('ALL platforms') !== -1 ||
+    commentRegion.indexOf('all platforms') !== -1 ||
+    commentRegion.indexOf('not just iSH') !== -1,
+    'comment should mention running on all platforms',
+  );
+});
+
+// =============================================================
+// 4. Env variable parsing
+// =============================================================
+
+runTest('parsePositiveMegabytesEnv exists and handles edge cases', () => {
+  assertContains(guardSource, 'function parsePositiveMegabytesEnv',
+    'should have env parsing function');
+  const fnIdx = guardSource.indexOf('function parsePositiveMegabytesEnv');
+  const fnBody = guardSource.substring(fnIdx, fnIdx + 300);
+  assertContains(fnBody, 'parseInt', 'should parse integer');
+  assertContains(fnBody, 'null', 'should return null for invalid');
+  assertContains(fnBody, '1024 * 1024', 'should convert MB to bytes');
+});
+
+runTest('ENV_HEAP_LIMIT reads from PAVE_MEMORY_HEAP', () => {
+  assertContains(guardSource, "parsePositiveMegabytesEnv('PAVE_MEMORY_HEAP')",
+    'should read PAVE_MEMORY_HEAP');
+});
+
+runTest('ENV_CRITICAL_LIMIT reads from PAVE_MEMORY_CRITICAL', () => {
+  assertContains(guardSource, "parsePositiveMegabytesEnv('PAVE_MEMORY_CRITICAL')",
+    'should read PAVE_MEMORY_CRITICAL');
+});
+
+// =============================================================
+// 5. onFirstSessionActivated still works
+// =============================================================
+
+runTest('onFirstSessionActivated callback is still invoked', () => {
+  const fnIdx = guardSource.indexOf('function notifySessionActivated');
+  const fnBody = guardSource.substring(fnIdx, fnIdx + 800);
+  assertContains(fnBody, 'onSessionActivatedCallback',
+    'should still call the registered callback');
+});
+
+runTest('index.js registers onFirstSessionActivated callback', () => {
+  assertContains(paveSource, 'onFirstSessionActivated(',
+    'should register callback for session activation');
+});
+
+// =============================================================
+// 6. Functional test: MemoryGuard with env overrides
+// =============================================================
+
+runTest('MemoryGuard constructor applies env to startupLimits when set', () => {
+  // Verify the Math.max pattern ensures env values override hardcoded defaults
+  const branches = getStartupBranches();
+  // Non-iSH heapUsed: Math.max(ENV_HEAP_LIMIT || 0, 200 * 1024 * 1024)
+  // This means if ENV_HEAP_LIMIT=400MB, result = max(400MB, 200MB) = 400MB
+  assertContains(branches.nonIsh, 'ENV_HEAP_LIMIT || 0',
+    'should use 0 fallback so Math.max picks the hardcoded default when env not set');
+});
+
+// =============================================================
+// Summary
+// =============================================================
+
+console.log('');
+console.log('Total: ' + total + ', Passed: ' + passed + ', Failed: ' + failed);
+if (failed > 0) {
+  process.exitCode = 1;
+}

package/test/pr233-fixes.test.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+
+'use strict';
+
+/**
+ * Tests for PR #233 Copilot review fixes (Issue #237)
+ *
+ * Fix 1: Wrong port fallback in abort HTTP POST (was 19747, should use PAVE_PORT default 4096)
+ * Fix 2: Dead EEXIST guard removed from writeInterrupt mkdirSync
+ * Fix 3: writeStatus includes port field for agent loop calls
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`✅ ${name}`);
+  } catch (e) {
+    failed++;
+    console.log(`❌ ${name}: ${e.message}`);
+  }
+}
+
+function assert(condition, msg) {
+  if (!condition) throw new Error(msg || 'Assertion failed');
+}
+
+function assertEqual(actual, expected, msg) {
+  if (actual !== expected) {
+    throw new Error((msg || '') + ` expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+// ============================================================
+// Test Suite 1: Fix 1 - Port fallback uses correct default
+// ============================================================
+
+console.log('\nTest Suite 1: Fix 1 - Port fallback in abort HTTP POST');
+
+test('abort port fallback uses serverUrl not hardcoded port', () => {
+  const indexSrc = fs.readFileSync(
+    path.join(__dirname, '..', 'index.js'), 'utf8',
+  );
+
+  // Should NOT contain the old wrong fallback
+  assert(
+    !indexSrc.includes('status.port || 19747'),
+    'index.js still contains wrong port fallback 19747',
+  );
+
+  // Should extract port from serverUrl (the actual listening address)
+  assert(
+    indexSrc.includes('new URL(status.serverUrl)'),
+    'index.js should parse serverUrl to extract real port',
+  );
+});
+
+test('abort port extraction matches agent-comm.js approach', () => {
+  const indexSrc = fs.readFileSync(
+    path.join(__dirname, '..', 'index.js'), 'utf8',
+  );
+
+  // Both pave/index.js and agent-comm.js should parse serverUrl
+  // instead of relying on status.port (which is always default 4096)
+  assert(
+    indexSrc.includes('parsed.port'),
+    'Should extract port from parsed URL',
+  );
+  assert(
+    indexSrc.includes('parsed.hostname'),
+    'Should extract hostname from parsed URL',
+  );
+});
+
+// ============================================================
+// Test Suite 2: Fix 2 - Dead EEXIST guard removed from writeInterrupt
+// ============================================================
+
+console.log('\nTest Suite 2: Fix 2 - Dead EEXIST guard in writeInterrupt');
+
+test('writeInterrupt mkdirSync does not have dead EEXIST guard', () => {
+  const registrySrc = fs.readFileSync(
+    path.join(__dirname, '..', 'lib', 'agent-registry.js'), 'utf8',
+  );
+
+  // Find the writeInterrupt function
+  const writeInterruptStart = registrySrc.indexOf('function writeInterrupt');
+  assert(writeInterruptStart !== -1, 'writeInterrupt function not found');
+
+  // Find the next function after writeInterrupt
+  const nextFuncStart = registrySrc.indexOf('\nfunction ', writeInterruptStart + 1);
+  const writeInterruptBody = registrySrc.substring(
+    writeInterruptStart,
+    nextFuncStart !== -1 ? nextFuncStart : writeInterruptStart + 2000,
+  );
+
+  // The mkdirSync block should NOT contain the EEXIST check
+  // Look for the pattern: mkdirSync followed by EEXIST within same try block
+  const mkdirIdx = writeInterruptBody.indexOf('mkdirSync');
+  assert(mkdirIdx !== -1, 'mkdirSync not found in writeInterrupt');
+
+  // Get the try/catch block around mkdirSync (next ~200 chars)
+  const mkdirBlock = writeInterruptBody.substring(mkdirIdx - 50, mkdirIdx + 200);
+
+  assert(
+    !mkdirBlock.includes("e.code !== 'EEXIST'"),
+    'writeInterrupt still contains dead EEXIST guard on mkdirSync',
+  );
+});
+
+test('writeInterrupt still catches real mkdir errors', () => {
+  const registrySrc = fs.readFileSync(
+    path.join(__dirname, '..', 'lib', 'agent-registry.js'), 'utf8',
+  );
+
+  const writeInterruptStart = registrySrc.indexOf('function writeInterrupt');
+  const nextFuncStart = registrySrc.indexOf('\nfunction ', writeInterruptStart + 1);
+  const writeInterruptBody = registrySrc.substring(
+    writeInterruptStart,
+    nextFuncStart !== -1 ? nextFuncStart : writeInterruptStart + 2000,
+  );
+
+  // Should still have error handling
+  assert(
+    writeInterruptBody.includes('Failed to create agent directory'),
+    'writeInterrupt lost its error message for mkdir failures',
+  );
+});
+
+test('writeInterrupt functional test - writes interrupt file correctly', () => {
+  // Skip if running in sandbox where fs.mkdirSync is not available
+  if (typeof fs.mkdirSync !== 'function') {
+    console.log('    (skipped - fs.mkdirSync not available in sandbox)');
+    return;
+  }
+
+  const registry = require(path.join(__dirname, '..', 'lib', 'agent-registry.js'));
+
+  // Use setAgentsDir to override the cached directory path
+  const tmpBase = path.join(os.tmpdir(), 'pave-test-pr233-' + process.pid + '-' + Date.now());
+  const tmpAgentsDir = path.join(tmpBase, 'agents');
+  fs.mkdirSync(tmpAgentsDir, { recursive: true });
+
+  registry.setAgentsDir(tmpAgentsDir);
+
+  try {
+    const result = registry.writeInterrupt('test-agent-pr233', 'test message', { action: 'stop' });
+    assert(result.success === true, 'writeInterrupt failed: ' + (result.error || 'unknown'));
+
+    // Verify the interrupt file exists and has correct content
+    const interruptPath = path.join(tmpAgentsDir, 'test-agent-pr233', 'interrupt.json');
+    assert(fs.existsSync(interruptPath), 'interrupt.json not created');
+
+    const data = JSON.parse(fs.readFileSync(interruptPath, 'utf8'));
+    assertEqual(data.action, 'stop');
+    assertEqual(data.message, 'test message');
+    assert(data.timestamp > 0, 'Missing timestamp');
+  } finally {
+    registry.resetAgentsDir();
+    try { fs.rmSync(tmpBase, { recursive: true, force: true }); } catch (e) {}
+  }
+});
+
+// ============================================================
+// Test Suite 3: Fix 3 - writeStatus includes port field
+// ============================================================
+
+console.log('\nTest Suite 3: Fix 3 - writeStatus includes port field');
+
+test('WORKING writeStatus call includes port field', () => {
+  const indexSrc = fs.readFileSync(
+    path.join(__dirname, '..', 'index.js'), 'utf8',
+  );
+
+  // Find writeStatus with STATES.WORKING
+  const workingIdx = indexSrc.indexOf("state: registry.STATES.WORKING");
+  assert(workingIdx !== -1, 'WORKING writeStatus not found');
+
+  // Get the block around it (look for closing })
+  const blockEnd = indexSrc.indexOf('});', workingIdx);
+  const block = indexSrc.substring(workingIdx, blockEnd);
+
+  assert(block.includes('port: actualPort'),
+    'WORKING writeStatus missing port: actualPort field');
+});
+
+test('SLEEPING writeStatus call includes port field', () => {
+  const indexSrc = fs.readFileSync(
+    path.join(__dirname, '..', 'index.js'), 'utf8',
+  );
+
+  const sleepingIdx = indexSrc.indexOf("state: registry.STATES.SLEEPING");
+  assert(sleepingIdx !== -1, 'SLEEPING writeStatus not found');
+
+  const blockEnd = indexSrc.indexOf('});', sleepingIdx);
+  const block = indexSrc.substring(sleepingIdx, blockEnd);
+
+  assert(block.includes('port: actualPort'),
+    'SLEEPING writeStatus missing port: actualPort field');
+});
+
+test('STOPPED writeStatus call includes port field', () => {
+  const indexSrc = fs.readFileSync(
+    path.join(__dirname, '..', 'index.js'), 'utf8',
+  );
+
+  // Find the second PORT definition (agent loop), not the first (server)
+  const portStr = "const PORT = args.port || parseInt(process.env.PAVE_PORT || '4096', 10);";
+  const firstPortIdx = indexSrc.indexOf(portStr);
+  assert(firstPortIdx !== -1, 'First PORT definition not found');
+  const portDefIdx = indexSrc.indexOf(portStr, firstPortIdx + portStr.length);
+  assert(portDefIdx !== -1, 'Agent loop PORT definition (second occurrence) not found');
+
+  const stoppedIdx = indexSrc.indexOf("state: registry.STATES.STOPPED", portDefIdx);
+  assert(stoppedIdx !== -1, 'STOPPED writeStatus after PORT def not found');
+
+  const blockEnd = indexSrc.indexOf('});', stoppedIdx);
+  const block = indexSrc.substring(stoppedIdx, blockEnd);
+
+  assert(block.includes('port: actualPort'),
+    'STOPPED writeStatus missing port: actualPort field');
+});
+
+test('STARTING writeStatus does NOT need port (PORT not yet defined)', () => {
+  const indexSrc = fs.readFileSync(
+    path.join(__dirname, '..', 'index.js'), 'utf8',
+  );
+
+  const startingIdx = indexSrc.indexOf("state: registry.STATES.STARTING");
+  assert(startingIdx !== -1, 'STARTING writeStatus not found');
+
+  const blockEnd = indexSrc.indexOf('});', startingIdx);
+  const block = indexSrc.substring(startingIdx, blockEnd);
+
+  // STARTING is called before the server starts, so port is not yet available
+  // This test documents that this is intentional
+  assert(!block.includes('port:'),
+    'STARTING writeStatus should not have port field (server not yet started)');
+});
+
+// ============================================================
+// Summary
+// ============================================================
+
+console.log('\n' + '='.repeat(50));
+console.log(`Results: ${passed} passed, ${failed} failed, ${passed + failed} total`);
+if (failed > 0) {
+  console.log('SOME TESTS FAILED');
+  process.exitCode = 1;
+} else {
+  console.log('ALL TESTS PASSED');
+}