@howlil/ez-agents 2.0.0

package/get-shit-done/bin/lib/test-logger.cjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for GSD Logger
+ * Run: node get-shit-done/bin/lib/test-logger.cjs
+ */
+
+const Logger = require('./logger.cjs');
+const path = require('path');
+
+console.log('='.repeat(50));
+console.log('Testing GSD Logger...');
+console.log('='.repeat(50));
+
+const logger = new Logger();
+
+console.log('\nLog file:', logger.getLogFile());
+console.log('\nRunning test logs...\n');
+
+// Test all log levels
+logger.debug('Debug message', { test: 'debug', timestamp: Date.now() });
+console.log('✓ Debug logged');
+
+logger.info('Info message', { test: 'info', component: 'test-logger' });
+console.log('✓ Info logged');
+
+logger.warn('Warning message', { test: 'warn', action: 'testing' });
+console.log('✓ Warning logged');
+
+logger.error('Error message', { test: 'error', code: 'TEST_ERROR' });
+console.log('✓ Error logged (check console output above)');
+
+// Verify log file was created
+const logFile = logger.getLogFile();
+if (require('fs').existsSync(logFile)) {
+  console.log('\n✓ Log file created:', logFile);
+  
+  // Read and parse log entries
+  const content = require('fs').readFileSync(logFile, 'utf-8');
+  const lines = content.trim().split('\n');
+  console.log(`✓ Log file contains ${lines.length} entries`);
+  
+  // Validate each entry
+  console.log('\nLog entries:');
+  lines.forEach((line, i) => {
+    try {
+      const entry = JSON.parse(line);
+      console.log(`  ${i + 1}. [${entry.level}] ${entry.message}`);
+    } catch (err) {
+      console.log(`  ${i + 1}. (parse error: ${err.message})`);
+    }
+  });
+  
+  console.log('\n' + '='.repeat(50));
+  console.log('Logger test PASSED ✓');
+  console.log('='.repeat(50));
+} else {
+  console.error('\n✗ Log file was not created');
+  process.exit(1);
+}

package/get-shit-done/bin/lib/test-safe-exec.cjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+const { safeExec, safeExecJSON, ALLOWED_COMMANDS } = require('./safe-exec.cjs');
+
+async function runTests() {
+  console.log('=== Testing safe-exec.cjs ===\n');
+  
+  // Test 1: Allowed command
+  console.log('Test 1: Allowed command (node --version)');
+  try {
+    const version = await safeExec('node', ['--version']);
+    console.log('✓ Result:', version);
+  } catch (err) { console.error('✗ Failed:', err.message); }
+  
+  // Test 2: Disallowed command
+  console.log('\nTest 2: Disallowed command (rm -rf /)');
+  try {
+    await safeExec('rm', ['-rf', '/']);
+    console.error('✗ Should have thrown error');
+  } catch (err) { console.log('✓ Blocked:', err.message); }
+  
+  // Test 3: Dangerous argument
+  console.log('\nTest 3: Dangerous argument (injection attempt)');
+  try {
+    await safeExec('echo', ['hello; rm -rf /']);
+    console.error('✗ Should have thrown error');
+  } catch (err) { console.log('✓ Blocked:', err.message); }
+  
+  // Test 4: Git command
+  console.log('\nTest 4: Git command (git --version)');
+  try {
+    const gitVersion = await safeExec('git', ['--version']);
+    console.log('✓ Result:', gitVersion);
+  } catch (err) { console.error('✗ Failed:', err.message); }
+  
+  console.log('\n=== Tests Complete ===');
+}
+
+runTests().catch(console.error);

package/get-shit-done/bin/lib/test-safe-path.cjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+const path = require('path');
+const { normalizePath, isPathSafe, validatePathExists, safeReadFile } = require('./safe-path.cjs');
+
+const testBase = __dirname;
+
+async function runTests() {
+  console.log('=== Testing safe-path.cjs ===\n');
+  
+  // Test 1: Safe path
+  console.log('Test 1: Safe path (logger.cjs)');
+  try {
+    const safe = normalizePath(testBase, 'logger.cjs');
+    console.log('✓ Normalized:', safe);
+  } catch (err) { console.error('✗ Failed:', err.message); }
+  
+  // Test 2: Path traversal
+  console.log('\nTest 2: Path traversal (../../../etc/passwd)');
+  try {
+    normalizePath(testBase, '../../../etc/passwd');
+    console.error('✗ Should have thrown error');
+  } catch (err) { console.log('✓ Blocked:', err.message); }
+  
+  // Test 3: isPathSafe
+  console.log('\nTest 3: isPathSafe boolean check');
+  console.log('  Safe (logger.cjs):', isPathSafe(testBase, 'logger.cjs'));
+  console.log('  Unsafe (../..):', isPathSafe(testBase, '../..'));
+  console.log('✓ Boolean checks working');
+  
+  console.log('\n=== Tests Complete ===');
+}
+
+runTests().catch(console.error);

package/get-shit-done/bin/lib/test-temp-file.cjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for GSD Temp File Handler
+ * Run: node get-shit-done/bin/lib/test-temp-file.cjs
+ */
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const {
+  createTempDir,
+  createTempFile,
+  writeToTemp,
+  readFromTemp,
+  cleanupTemp,
+  cleanupAll,
+  getTrackedTemps,
+  isPathSafe
+} = require('./temp-file.cjs');
+
+async function testCreateTempDir() {
+  console.log('\n=== Test 1: Create Temp Directory ===');
+  
+  const tempDir = await createTempDir('gsd-test-');
+  console.log('Created temp dir:', tempDir);
+  
+  const exists = require('fs').existsSync(tempDir);
+  console.log('Directory exists:', exists);
+  
+  if (!exists) throw new Error('Temp dir was not created');
+  console.log('✓ Temp directory created successfully');
+  
+  return tempDir;
+}
+
+async function testCreateTempFile(tempDir) {
+  console.log('\n=== Test 2: Create Temp File ===');
+  
+  const tempFile = await createTempFile('test-', tempDir, 'Initial content');
+  console.log('Created temp file:', tempFile);
+  
+  const content = await readFromTemp(tempFile, { validateBase: tempDir });
+  console.log('File content:', content);
+  
+  if (content !== 'Initial content') {
+    throw new Error('File content mismatch');
+  }
+  console.log('✓ Temp file created and read successfully');
+  
+  return tempFile;
+}
+
+async function testWriteToTemp(tempFile, tempDir) {
+  console.log('\n=== Test 3: Write to Temp File ===');
+  
+  await writeToTemp(tempFile, 'Updated content', { validateBase: tempDir });
+  const content = await readFromTemp(tempFile, { validateBase: tempDir });
+  
+  console.log('Updated content:', content);
+  
+  if (content !== 'Updated content') {
+    throw new Error('Write failed');
+  }
+  console.log('✓ Temp file write successful');
+}
+
+async function testPathSafety() {
+  console.log('\n=== Test 4: Path Safety Validation ===');
+  
+  const baseDir = os.tmpdir();
+  
+  // Safe paths
+  console.log('Safe path (same dir):', isPathSafe(baseDir, path.join(baseDir, 'file.txt')));
+  console.log('Safe path (subdir):', isPathSafe(baseDir, path.join(baseDir, 'sub', 'file.txt')));
+  
+  // Unsafe paths (should be false)
+  const unsafePath = path.resolve(baseDir, '..', '..', 'etc', 'passwd');
+  console.log('Unsafe path (/etc/passwd):', isPathSafe(baseDir, unsafePath));
+  
+  console.log('✓ Path safety validation working');
+}
+
+async function testCleanup(tempFile, tempDir) {
+  console.log('\n=== Test 5: Cleanup ===');
+  
+  console.log('Tracked temps before cleanup:', getTrackedTemps().length);
+  
+  await cleanupTemp(tempFile);
+  console.log('Cleaned up temp file');
+  
+  const fileExists = require('fs').existsSync(tempFile);
+  console.log('Temp file exists after cleanup:', fileExists);
+  
+  await cleanupAll();
+  console.log('Cleaned up all temps');
+  
+  const dirExists = require('fs').existsSync(tempDir);
+  console.log('Temp dir exists after cleanup:', dirExists);
+  
+  console.log('✓ Cleanup successful');
+}
+
+async function runTests() {
+  const os = require('os');
+  const path = require('path');
+  
+  try {
+    const tempDir = await testCreateTempDir();
+    const tempFile = await testCreateTempFile(tempDir);
+    await testWriteToTemp(tempFile, tempDir);
+    await testPathSafety();
+    await testCleanup(tempFile, tempDir);
+    
+    console.log('\n' + '='.repeat(50));
+    console.log('Temp File Handler test COMPLETE ✓');
+    console.log('='.repeat(50));
+  } catch (err) {
+    console.error('Test failed:', err);
+    process.exit(1);
+  }
+}
+
+runTests();

package/get-shit-done/bin/lib/timeout-exec.cjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * GSD Timeout Exec — Command execution with timeout and fallback
+ * 
+ * Provides safe command execution with configurable timeout
+ * Logs errors and supports fallback values
+ * 
+ * Usage:
+ *   const { execWithTimeout } = require('./timeout-exec.cjs');
+ *   const result = await execWithTimeout('node', ['script.js'], { timeout: 5000, fallback: 'default' });
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const execFileAsync = promisify(execFile);
+const Logger = require('./logger.cjs');
+const logger = new Logger();
+
+const DEFAULT_TIMEOUT = 5000; // 5 seconds
+
+/**
+ * Execute a command with timeout
+ * @param {string} cmd - Command to execute
+ * @param {string[]} args - Command arguments
+ * @param {Object} options - Execution options
+ * @param {number} options.timeout - Timeout in milliseconds (default: 5000)
+ * @param {any} options.fallback - Fallback value if command fails or times out
+ * @returns {Promise<string>} - Command stdout or fallback value
+ */
+async function execWithTimeout(cmd, args, options = {}) {
+  const { timeout = DEFAULT_TIMEOUT, fallback = null } = options;
+  
+  return new Promise(async (resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      logger.error(`Command timed out: ${cmd} ${args.join(' ')}`, { timeout });
+      if (fallback) {
+        logger.info('Using fallback value', { fallback });
+        resolve(fallback);
+      } else {
+        reject(new Error(`Command timed out after ${timeout}ms: ${cmd}`));
+      }
+    }, timeout);
+
+    try {
+      const result = await execFileAsync(cmd, args, { timeout });
+      clearTimeout(timeoutId);
+      resolve(result.stdout.trim());
+    } catch (err) {
+      clearTimeout(timeoutId);
+      logger.error(`Command failed: ${cmd}`, { error: err.message, args });
+      if (fallback) {
+        logger.info('Using fallback value', { fallback });
+        resolve(fallback);
+      } else {
+        reject(err);
+      }
+    }
+  });
+}
+
+module.exports = { execWithTimeout };