@cnrai/pave 0.3.35 → 0.3.51

package/test/agent-lifecycle.test.js

@@ -1,520 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for agent lifecycle commands (Issue #199)
- *
- * Verifies:
- * - resolveAgentName() prefix matching
- * - getAgentLogFile() log path resolution
- * - stopAgent() SIGTERM + SIGKILL behavior
- * - args-parser recognizes stop, logs, --daemon, --follow, --lines
- * - handleAgentStop/handleAgentLogs routing in index.js
- *
- * Run with: node test/agent-lifecycle.test.js
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-let passed = 0;
-let failed = 0;
-
-function runTest(name, fn) {
-  try {
-    fn();
-    console.log('\u2705 ' + name);
-    passed++;
-  } catch (e) {
-    console.log('\u274C ' + name + ': ' + e.message);
-    failed++;
-  }
-}
-
-function assert(cond, msg) {
-  if (!cond) throw new Error(msg || 'Assertion failed');
-}
-
-/**
- * Run an async stopAgent test in a child process so the result is
- * available synchronously to the test runner.  The child inherits the
- * temp agents dir via an environment variable.
- */
-function runStopAgentTest(setupCode, assertCode) {
-  if (!registryReady) return; // skip in sandbox
-  const cp = require('child_process');
-  const script = [
-    'var registry = require(' + JSON.stringify(require.resolve('../lib/agent-registry')) + ');',
-    'registry.setAgentsDir(' + JSON.stringify(tmpDir) + ');',
-    setupCode,
-    'registry.stopAgent.apply(null, args).then(function(result) {',
-    '  try {',
-    assertCode,
-    '  } catch (e) { process.stderr.write(e.message); process.exit(1); }',
-    '});',
-  ].join('\n');
-  const r = cp.spawnSync(process.execPath, ['-e', script], {
-    timeout: 10000,
-    encoding: 'utf-8',
-  });
-  if (r.status !== 0) {
-    throw new Error(r.stderr || 'child exited with code ' + r.status);
-  }
-}
-
-// ============================================================
-// Args-parser tests
-// ============================================================
-
-const spawnSync = require('child_process').spawnSync;
-const parseArgs = require('../lib/args-parser').parseArgs;
-
-runTest('pave agent stop sets agentSubcommand to stop', () => {
-  const args = parseArgs(['agent', 'stop', 'my-agent']);
-  assert(args.command === 'agent', 'command should be agent');
-  assert(args.agentSubcommand === 'stop', 'subcommand should be stop, got: ' + args.agentSubcommand);
-  assert(args.commandArgs[0] === 'my-agent', 'commandArgs[0] should be my-agent');
-});
-
-runTest('pave agent stop without name has empty commandArgs', () => {
-  const args = parseArgs(['agent', 'stop']);
-  assert(args.command === 'agent', 'command should be agent');
-  assert(args.agentSubcommand === 'stop', 'subcommand should be stop');
-  assert(args.commandArgs.length === 0, 'commandArgs should be empty');
-});
-
-runTest('pave agent logs sets agentSubcommand to logs', () => {
-  const args = parseArgs(['agent', 'logs', 'my-agent']);
-  assert(args.command === 'agent', 'command should be agent');
-  assert(args.agentSubcommand === 'logs', 'subcommand should be logs');
-  assert(args.commandArgs[0] === 'my-agent', 'commandArgs[0] should be my-agent');
-});
-
-runTest('pave agent logs without name has empty commandArgs', () => {
-  const args = parseArgs(['agent', 'logs']);
-  assert(args.command === 'agent', 'command should be agent');
-  assert(args.agentSubcommand === 'logs', 'subcommand should be logs');
-  assert(args.commandArgs.length === 0, 'commandArgs should be empty');
-});
-
-runTest('pave agent logs --follow sets follow flag', () => {
-  const args = parseArgs(['agent', 'logs', '--follow']);
-  assert(args.agentSubcommand === 'logs', 'subcommand should be logs');
-  assert(args.follow === true, 'follow should be true');
-});
-
-runTest('pave agent logs -f sets follow flag (short flag)', () => {
-  const args = parseArgs(['agent', 'logs', '-f']);
-  assert(args.agentSubcommand === 'logs', 'subcommand should be logs');
-  assert(args.follow === true, 'follow should be true');
-});
-
-runTest('pave agent logs --lines 50 sets lines to 50', () => {
-  const args = parseArgs(['agent', 'logs', '--lines', '50']);
-  assert(args.agentSubcommand === 'logs', 'subcommand should be logs');
-  assert(args.lines === 50, 'lines should be 50, got: ' + args.lines);
-});
-
-runTest('pave agent logs -n 50 sets lines to 50 (short flag)', () => {
-  const args = parseArgs(['agent', 'logs', '-n', '50']);
-  assert(args.agentSubcommand === 'logs', 'subcommand should be logs');
-  assert(args.lines === 50, 'lines should be 50, got: ' + args.lines);
-});
-
-runTest('pave agent logs --follow --lines 20 sets both', () => {
-  const args = parseArgs(['agent', 'logs', 'my-agent', '--follow', '--lines', '20']);
-  assert(args.agentSubcommand === 'logs', 'subcommand should be logs');
-  assert(args.follow === true, 'follow should be true');
-  assert(args.lines === 20, 'lines should be 20');
-  assert(args.commandArgs[0] === 'my-agent', 'commandArgs[0] should be my-agent');
-});
-
-runTest('pave agent --daemon sets daemon flag', () => {
-  const args = parseArgs(['agent', '--daemon']);
-  assert(args.command === 'agent', 'command should be agent');
-  assert(args.daemon === true, 'daemon should be true');
-  assert(!args.agentSubcommand, 'subcommand should be null');
-});
-
-runTest('pave agent --daemon --name test sets both', () => {
-  const args = parseArgs(['agent', '--daemon', '--name', 'test']);
-  assert(args.daemon === true, 'daemon should be true');
-  assert(args.name === 'test', 'name should be test');
-});
-
-runTest('agent stop does not apply SOUL defaults', () => {
-  const args = parseArgs(['agent', 'stop', 'x']);
-  assert(args.commandArgs.length === 1, 'should have 1 arg: ' + args.commandArgs.length);
-  // stop subcommand shouldn't have AGENTS.md default
-  assert(args.commandArgs[0] === 'x', 'arg should be x, got: ' + args.commandArgs[0]);
-});
-
-runTest('agent logs does not apply SOUL defaults', () => {
-  const args = parseArgs(['agent', 'logs']);
-  // logs subcommand shouldn't get AGENTS.md as default
-  assert(args.commandArgs.length === 0, 'commandArgs should be empty, got: ' + args.commandArgs.length);
-});
-
-runTest('agent with no subcommand still gets defaults', () => {
-  const args = parseArgs(['agent']);
-  assert(!args.agentSubcommand, 'subcommand should be null');
-  assert(args.sleep === '1m', 'default sleep should be 1m');
-  assert(args.commandArgs.length === 1, 'should have 1 default arg');
-  assert(args.commandArgs[0] === 'AGENTS.md', 'default SOUL should be AGENTS.md');
-});
-
-// ============================================================
-// Agent registry tests (functional using temp directories)
-// ============================================================
-
-let registry;
-try {
-  registry = require('../lib/agent-registry');
-} catch (e) {
-  // May fail in sandbox; tests below will skip
-  registry = null;
-}
-
-// Set up a temp directory for registry tests
-let tmpDir;
-let registryReady = false;
-if (registry) {
-  try {
-    tmpDir = path.join(os.tmpdir(), 'pave-test-' + process.pid + '-' + Date.now());
-    fs.mkdirSync(tmpDir, { recursive: true });
-    registry.setAgentsDir(tmpDir);
-    registryReady = true;
-  } catch (e) {
-    // Sandbox may restrict mkdirSync; fall back to export-only checks
-    registryReady = false;
-  }
-}
-
-// Clean up on exit
-if (typeof process.on === 'function') {
-  process.on('exit', () => {
-    if (registryReady) {
-      try {
-        registry.resetAgentsDir();
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-      } catch (_) {}
-    }
-    try {
-      fs.rmSync(isolatedHome, { recursive: true, force: true });
-    } catch (_) {}
-  });
-}
-
-runTest('agent-registry exports resolveAgentName', () => {
-  assert(registry, 'registry module should load');
-  assert(typeof registry.resolveAgentName === 'function', 'resolveAgentName should be a function');
-});
-
-runTest('agent-registry exports stopAgent', () => {
-  assert(registry, 'registry module should load');
-  assert(typeof registry.stopAgent === 'function', 'stopAgent should be a function');
-});
-
-runTest('agent-registry exports getAgentLogFile', () => {
-  assert(registry, 'registry module should load');
-  assert(typeof registry.getAgentLogFile === 'function', 'getAgentLogFile should be a function');
-});
-
-runTest('resolveAgentName returns error for empty input', () => {
-  assert(registry, 'registry module should load');
-  const result = registry.resolveAgentName('');
-  assert(result.name === null, 'name should be null');
-  assert(result.error !== null, 'error should be set');
-});
-
-runTest('resolveAgentName rejects garbage input that sanitizes to default', () => {
-  assert(registry, 'registry module should load');
-  // Spaces/punctuation sanitize to empty string -> "default" via sanitizeName
-  const result = registry.resolveAgentName('   !!!   ');
-  assert(result.name === null, 'name should be null for garbage input');
-  assert(result.error && result.error.indexOf('Invalid') >= 0, 'error should mention invalid, got: ' + result.error);
-});
-
-runTest('resolveAgentName allows explicit "default" input', () => {
-  assert(registry, 'registry module should load');
-  // Explicit "default" should pass the guard (even if no agent named "default" exists)
-  const result = registry.resolveAgentName('default');
-  // May return not-found error, but should NOT return "Invalid agent name"
-  assert(!result.error || result.error.indexOf('Invalid') === -1,
-    'should not say Invalid for explicit "default", got: ' + result.error);
-});
-
-runTest('resolveAgentName finds exact match', () => {
-  if (!registryReady) return; // skip in sandbox
-  // Write a status file for an agent
-  registry.writeStatus('test-exact', { state: 'working', pid: process.pid, cwd: '/tmp' });
-  const result = registry.resolveAgentName('test-exact');
-  assert(result.name === 'test-exact', 'should find exact match, got: ' + result.name);
-  assert(result.error === null, 'error should be null');
-});
-
-runTest('resolveAgentName finds prefix match', () => {
-  if (!registryReady) return; // skip in sandbox
-  registry.writeStatus('prefix-alpha-agent', { state: 'working', pid: process.pid, cwd: '/tmp' });
-  const result = registry.resolveAgentName('prefix-alpha');
-  assert(result.name === 'prefix-alpha-agent', 'should find prefix match, got: ' + result.name);
-});
-
-runTest('resolveAgentName reports ambiguous matches', () => {
-  if (!registryReady) return; // skip in sandbox
-  registry.writeStatus('ambig-one', { state: 'working', pid: process.pid, cwd: '/tmp' });
-  registry.writeStatus('ambig-two', { state: 'working', pid: process.pid, cwd: '/tmp' });
-  const result = registry.resolveAgentName('ambig');
-  assert(result.name === null, 'name should be null for ambiguous');
-  assert(result.error && result.error.indexOf('Ambiguous') >= 0, 'error should mention ambiguous');
-  assert(result.candidates.length === 2, 'should have 2 candidates');
-});
-
-runTest('resolveAgentName returns error for no match', () => {
-  if (!registryReady) return; // skip in sandbox
-  const result = registry.resolveAgentName('nonexistent-xyz');
-  assert(result.name === null, 'name should be null');
-  assert(result.error && result.error.indexOf('No agent found') >= 0, 'error should mention not found');
-});
-
-runTest('getAgentLogFile returns error for unknown agent', () => {
-  assert(registry, 'registry module should load');
-  const result = registry.getAgentLogFile('totally-unknown-agent');
-  assert(result.path === null, 'path should be null for unknown agent');
-  assert(result.error !== null, 'error should be set for unknown agent');
-});
-
-runTest('getAgentLogFile resolves log path from status', () => {
-  if (!registryReady) return; // skip in sandbox
-  registry.writeStatus('log-test-agent', {
-    state: 'working', pid: process.pid, cwd: '/home/user/project', config: '.pave',
-  });
-  const result = registry.getAgentLogFile('log-test-agent');
-  assert(result.error === null, 'error should be null');
-  assert(result.path === path.join('/home/user/project', '.pave', 'pave.log'),
-    'should resolve log path, got: ' + result.path);
-});
-
-runTest('stopAgent returns error for unknown agent', () => {
-  assert(registry, 'registry module should load');
-  runStopAgentTest(
-    'var args = ["nonexistent-stop-test"];',
-    'if (result.success) throw new Error("should not succeed for unknown agent");' +
-    'if (!result.error || result.error.indexOf("not found") < 0) throw new Error("error should mention not found, got: " + result.error);',
-  );
-});
-
-runTest('stopAgent returns error for already stopped agent', () => {
-  if (!registryReady) return; // skip in sandbox
-  registry.writeStatus('stopped-agent', { state: 'stopped', pid: 99999 });
-  runStopAgentTest(
-    'var args = ["stopped-agent"];',
-    'if (result.success) throw new Error("should not succeed for stopped agent");' +
-    'if (!result.error || result.error.indexOf("already stopped") < 0) throw new Error("error should mention already stopped, got: " + result.error);',
-  );
-});
-
-runTest('stopAgent handles stale/dead process', () => {
-  if (!registryReady) return; // skip in sandbox
-  // PID 2147483647 should not exist on any system
-  registry.writeStatus('stale-agent', { state: 'working', pid: 2147483647 });
-  runStopAgentTest(
-    'var args = ["stale-agent"];',
-    'if (!result.success) throw new Error("should succeed for stale process, got: " + result.error);',
-  );
-  // Verify status was updated
-  const status = registry.readStatus('stale-agent');
-  assert(status && status.state === 'stopped', 'state should be stopped, got: ' + (status && status.state));
-});
-
-// ============================================================
-// Index.js behavioral tests (CLI spawn instead of source inspection)
-// ============================================================
-//
-// These tests exercise the CLI via child_process.spawnSync and assert
-// on exit codes and observable output, rather than reading index.js as
-// raw text and matching on specific substrings.
-
-const cliPath = path.join(__dirname, '..', 'index.js');
-const nodeBin = process.execPath || 'node';
-
-// Use an isolated HOME so the child processes won't discover the real
-// ~/.pave/agents/ directory (which may contain a running coder agent).
-let isolatedHome = path.join(os.tmpdir(), 'pave-cli-test-home-' + process.pid);
-let isolatedHomeReady = false;
-try {
-  if (typeof fs.mkdirSync === 'function') {
-    fs.mkdirSync(isolatedHome, { recursive: true });
-    isolatedHomeReady = true;
-  }
-} catch (_) {}
-
-// Detect whether spawnSync actually works (sandbox may stub it out).
-let canSpawn = false;
-try {
-  const probe = spawnSync(nodeBin, ['-e', 'process.stdout.write("OK")'], {
-    encoding: 'utf-8', timeout: 5000,
-  });
-  canSpawn = (probe.stdout === 'OK') && isolatedHomeReady;
-} catch (_) {}
-
-function runCli(cliArgs, opts) {
-  const mergedEnv = { ...process.env,
-    NO_COLOR: '1',
-    HOME: isolatedHome };
-  const mergedOpts = { encoding: 'utf-8',
-    timeout: 5000,
-    env: mergedEnv,
-    cwd: isolatedHome,
-    ...opts || {} };
-  // Ensure env overrides from caller still use the isolated HOME
-  if (opts && opts.env) {
-    mergedOpts.env = { ...mergedEnv, ...opts.env };
-  }
-  const result = spawnSync(nodeBin, [cliPath].concat(cliArgs), mergedOpts);
-  return {
-    stdout: (result.stdout || '').trim(),
-    stderr: (result.stderr || '').trim(),
-    status: result.status,
-  };
-}
-
-runTest('pave agent stop with no agent shows usage help', () => {
-  if (!canSpawn) return; // skip when spawnSync is not reliable
-  // Isolated HOME has no .pave/agents, so stop should give a helpful error
-  const r = runCli(['agent', 'stop']);
-  assert(r.status !== 0, 'exit code should be non-zero, got: ' + r.status);
-  assert(r.stderr.includes('No agent found') || r.stderr.includes('pave agent stop'),
-    'should show stop usage info, got: ' + r.stderr);
-});
-
-runTest('pave agent logs with no log file shows error', () => {
-  if (!canSpawn) return; // skip when spawnSync is not reliable
-  const r = runCli(['agent', 'logs']);
-  assert(r.status !== 0, 'exit code should be non-zero, got: ' + r.status);
-  assert(r.stderr.includes('not found') || r.stderr.includes('Error'),
-    'should show log error, got: ' + r.stderr);
-});
-
-runTest('pave agent stop detects --name conflict with positional', () => {
-  if (!canSpawn) return; // skip when spawnSync is not reliable
-  const r = runCli(['agent', 'stop', 'agent-a', '--name', 'agent-b']);
-  assert(r.status !== 0, 'exit code should be non-zero');
-  assert(r.stderr.includes('Conflicting agent names'), 'should detect conflict, got: ' + r.stderr);
-});
-
-runTest('pave agent logs detects --name conflict with positional', () => {
-  if (!canSpawn) return; // skip when spawnSync is not reliable
-  const r = runCli(['agent', 'logs', 'agent-a', '--name', 'agent-b']);
-  assert(r.status !== 0, 'exit code should be non-zero');
-  assert(r.stderr.includes('Conflicting agent names'), 'should detect conflict, got: ' + r.stderr);
-});
-
-runTest('pave agent --help shows daemon, stop, and logs', () => {
-  if (!canSpawn) return; // skip when spawnSync is not reliable
-  const r = runCli(['agent', '--help']);
-  const output = r.stdout + r.stderr;
-  assert(output.includes('--daemon'), 'help should mention --daemon');
-  assert(output.includes('stop'), 'help should mention stop');
-  assert(output.includes('logs'), 'help should mention logs');
-});
-
-// ============================================================
-// Args validation tests
-// ============================================================
-
-runTest('stop/logs reject multiple positional args', () => {
-  if (!canSpawn) return; // skip when spawnSync is not reliable
-
-  // stop with two positional agent names should fail
-  const rStop = runCli(['agent', 'stop', 'agent-a', 'agent-b']);
-  assert(rStop.status !== 0, 'stop with multiple agent names should have non-zero exit code');
-  assert(
-    (rStop.stderr + rStop.stdout).includes('accepts at most one agent name'),
-    'stop should show usage error about accepting at most one agent name; got: ' + rStop.stderr,
-  );
-
-  // logs with two positional agent names should also fail
-  const rLogs = runCli(['agent', 'logs', 'agent-a', 'agent-b']);
-  assert(rLogs.status !== 0, 'logs with multiple agent names should have non-zero exit code');
-  assert(
-    (rLogs.stderr + rLogs.stdout).includes('accepts at most one agent name'),
-    'logs should show usage error about accepting at most one agent name; got: ' + rLogs.stderr,
-  );
-});
-
-runTest('resolveAgentName returns I/O error for missing agents directory', () => {
-  if (!registryReady) return; // skip in sandbox
-  // Point agents dir to a non-existent path, then try to resolve
-  const badDir = path.join(os.tmpdir(), 'pave-test-nonexistent-' + process.pid);
-  registry.setAgentsDir(badDir);
-  try {
-    const result = registry.resolveAgentName('anything');
-    // Should get an error (not found or I/O error), not a crash
-    assert(result.error, 'should return an error when agents dir does not exist, got: ' + JSON.stringify(result));
-  } finally {
-    // Restore the test agents dir
-    registry.setAgentsDir(tmpDir);
-  }
-});
-
-runTest('stopAgent marks stale agent as stopped for observed PID', () => {
-  if (!registryReady) return; // skip in sandbox
-  // Simulate: agent had dead PID A, then a new agent overwrites status with
-  // dead PID B (both dead in tests). stopAgent reads status, observes PID B,
-  // and since PID B is dead it takes the stale path and writes STOPPED for
-  // the PID it observed. The re-read guard only prevents overwriting if the
-  // status changes between stopAgent's initial read and its write.
-  const deadPid = 2147483647;
-  const newPid = 2147483646;
-  // Write initial status with dead PID
-  registry.writeStatus('pid-race-agent', { state: 'working', pid: deadPid });
-  // Immediately overwrite with "restarted" agent (different PID, also dead)
-  registry.writeStatus('pid-race-agent', { state: 'working', pid: newPid });
-  // stopAgent reads status, sees pid=newPid (dead). Takes the stale path
-  // and marks it stopped. This is correct behavior - the guard only fires
-  // if the PID changes AFTER the read.
-  runStopAgentTest(
-    'var args = ["pid-race-agent"];',
-    'if (!result.success) throw new Error("should succeed, got: " + result.error);',
-  );
-  const finalStatus = registry.readStatus('pid-race-agent');
-  assert(finalStatus, 'status should exist');
-  assert(finalStatus.state === 'stopped', 'should be stopped, got: ' + finalStatus.state);
-});
-
-runTest('stopAgent does not call releaseAgent to avoid lock corruption', () => {
-  // stopAgent must not directly unlink the lock file because a new agent may
-  // have claimed it between the PID dying and the status update. claimAgent()
-  // handles stale locks on its own.
-  const regSource = fs.readFileSync(
-    path.join(__dirname, '..', 'lib', 'agent-registry.js'), 'utf-8',
-  );
-  // Extract the stopAgent function body
-  const fnStart = regSource.indexOf('function stopAgent(');
-  let fnEnd = regSource.indexOf('\nfunction ', fnStart + 1);
-  if (fnEnd === -1) fnEnd = regSource.indexOf('\nmodule.exports', fnStart + 1);
-  const fnBody = regSource.substring(fnStart, fnEnd);
-  // Split into lines and check for non-comment releaseAgent calls
-  const lines = fnBody.split('\n');
-  const activeCalls = [];
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
-    // Skip comment-only lines
-    if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*')) continue;
-    if (trimmed.indexOf('releaseAgent(') !== -1) {
-      activeCalls.push(lines[i].trim());
-    }
-  }
-  assert(activeCalls.length === 0,
-    'stopAgent should not call releaseAgent(); found: ' + activeCalls.join(' | '));
-});
-
-// ============================================================
-// Report results
-// ============================================================
-
-console.log('\nResults: ' + passed + ' passed, ' + failed + ' failed');
-
-if (failed > 0) {
-  throw new Error(failed + ' agent-lifecycle test(s) failed');
-}