@howlil/ez-agents 3.1.0 → 3.4.2

package/ez-agents/bin/lib/planning-write.cjs

@@ -0,0 +1,107 @@
+/**
+ * Planning Write — lock/temp-safe writer for .planning mutations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { Worker } = require('worker_threads');
+const { withLock } = require('./file-lock.cjs');
+const { createTempFile, cleanupTemp } = require('./temp-file.cjs');
+
+function normalizeTimeoutError(err, filePath) {
+  if (!err) return err;
+  const message = err.message || '';
+  if (message.includes('File locked:')) {
+    return err;
+  }
+  if (message.includes('timed out') || err.code === 'ELOCKED') {
+    return new Error(`File locked: ${filePath}`);
+  }
+  return err;
+}
+
+async function safePlanningWrite(filePath, content, options = {}) {
+  const {
+    timeoutMs = 30000,
+    tempPrefix = 'ez-write-',
+  } = options;
+
+  let tempPath = null;
+
+  try {
+    await withLock(filePath, async () => {
+      tempPath = await createTempFile(tempPrefix, path.dirname(filePath), content);
+      await fs.promises.rename(tempPath, filePath);
+    }, { timeout: timeoutMs });
+  } catch (err) {
+    throw normalizeTimeoutError(err, filePath);
+  } finally {
+    if (tempPath) {
+      try {
+        await cleanupTemp(tempPath);
+      } catch {
+        // best effort cleanup only
+      }
+    }
+  }
+}
+
+function safePlanningWriteSync(filePath, content, options = {}) {
+  const signalBuffer = new SharedArrayBuffer(4);
+  const signal = new Int32Array(signalBuffer);
+  const errorPath = path.join(os.tmpdir(), `ez-planning-write-error-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.log`);
+  const modulePath = __filename;
+
+  const workerCode = `
+    const fs = require('fs');
+    const { workerData } = require('worker_threads');
+    const signal = new Int32Array(workerData.signalBuffer);
+    const { safePlanningWrite } = require(workerData.modulePath);
+    (async () => {
+      try {
+        await safePlanningWrite(workerData.filePath, workerData.content, workerData.options);
+        Atomics.store(signal, 0, 1);
+      } catch (err) {
+        try {
+          fs.writeFileSync(workerData.errorPath, err && (err.stack || err.message) ? (err.stack || err.message) : String(err), 'utf-8');
+        } catch {}
+        Atomics.store(signal, 0, 2);
+      } finally {
+        Atomics.notify(signal, 0);
+      }
+    })();
+  `;
+
+  const worker = new Worker(workerCode, {
+    eval: true,
+    workerData: { modulePath, filePath, content, options, signalBuffer, errorPath },
+  });
+
+  try {
+    while (Atomics.load(signal, 0) === 0) {
+      Atomics.wait(signal, 0, 0, 100);
+    }
+  } finally {
+    worker.terminate().catch(() => {});
+  }
+
+  const status = Atomics.load(signal, 0);
+  if (status === 2) {
+    let message = `safePlanningWriteSync failed for ${filePath}`;
+    try {
+      if (fs.existsSync(errorPath)) {
+        message = fs.readFileSync(errorPath, 'utf-8') || message;
+      }
+    } catch {}
+    try { fs.rmSync(errorPath, { force: true }); } catch {}
+    throw new Error(message);
+  }
+
+  try { fs.rmSync(errorPath, { force: true }); } catch {}
+}
+
+module.exports = {
+  safePlanningWrite,
+  safePlanningWriteSync,
+};

package/ez-agents/bin/lib/retry.cjs

@@ -1,119 +1,119 @@
-#!/usr/bin/env node
-
-/**
- * GSD Retry — Retry utility with exponential backoff
- * 
- * Features:
- * - Configurable max retries, base delay, max delay
- * - Jitter to prevent thundering herd
- * - Error classification (retryable vs non-retryable)
- * 
- * Usage:
- *   const { retry, isRetryableError } = require('./retry.cjs');
- *   const result = await retry(() => fetch(url), { maxRetries: 3 });
- */
-
-const Logger = require('./logger.cjs');
-const logger = new Logger();
-
-/**
- * Retry an operation with exponential backoff
- * @param {Function} operation - Async function to retry
- * @param {Object} options - Retry options
- * @returns {Promise<any>} - Result of operation
- */
-async function retry(operation, options = {}) {
-  const {
-    maxRetries = 3,
-    baseDelay = 1000,
-    maxDelay = 30000,
-    jitter = true,
-    shouldRetry = isRetryableError
-  } = options;
-
-  let lastError;
-  let lastAttempt = null;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      lastAttempt = attempt;
-      return await operation();
-    } catch (err) {
-      lastError = err;
-      
-      // Don't retry if error is not retryable or max retries reached
-      if (attempt === maxRetries || !shouldRetry(err)) {
-        logger.error('Operation failed after retries', { 
-          attempts: attempt + 1, 
-          error: err.message 
-        });
-        break;
-      }
-
-      // Calculate delay with exponential backoff and jitter
-      const delay = Math.min(
-        baseDelay * Math.pow(2, attempt),
-        maxDelay
-      );
-      const jitteredDelay = jitter ? delay * (0.5 + Math.random()) : delay;
-
-      logger.warn('Retrying operation', { 
-        attempt: attempt + 1, 
-        maxRetries, 
-        delay: Math.round(jitteredDelay),
-        error: err.message 
-      });
-
-      await new Promise(resolve => setTimeout(resolve, jitteredDelay));
-    }
-  }
-
-  const error = new Error(`Operation failed after ${lastAttempt + 1} attempts: ${lastError.message}`);
-  error.cause = lastError;
-  throw error;
-}
-
-/**
- * Check if error is retryable
- * @param {Error} err - Error to check
- * @returns {boolean} - True if retryable
- */
-function isRetryableError(err) {
-  const retryableCodes = ['ECONNRESET', 'ETIMEDOUT', 'EAI_AGAIN', 'ENOTFOUND'];
-  const retryableStatus = [429, 500, 502, 503, 504];
-
-  if (err.code && retryableCodes.includes(err.code)) return true;
-  if (err.status && retryableStatus.includes(err.status)) return true;
-  if (err.message?.includes('rate limit')) return true;
-  if (err.message?.includes('timeout')) return true;
-  if (err.message?.includes('network')) return true;
-
-  return false;
-}
-
-/**
- * Classify error type
- * @param {Error} err - Error to classify
- * @returns {string} - Error classification
- */
-function classifyError(err) {
-  if (isRetryableError(err)) {
-    return 'retryable';
-  }
-  
-  if (err.code === 'ENOENT' || err.code === 'EPERM') {
-    return 'filesystem';
-  }
-  
-  if (err.message?.includes('parse') || err.message?.includes('invalid')) {
-    return 'validation';
-  }
-  
-  return 'unknown';
-}
-
-module.exports = {
-  retry,
-  isRetryableError,
-  classifyError
-};
+#!/usr/bin/env node
+
+/**
+ * EZ Retry — Retry utility with exponential backoff
+ * 
+ * Features:
+ * - Configurable max retries, base delay, max delay
+ * - Jitter to prevent thundering herd
+ * - Error classification (retryable vs non-retryable)
+ * 
+ * Usage:
+ *   const { retry, isRetryableError } = require('./retry.cjs');
+ *   const result = await retry(() => fetch(url), { maxRetries: 3 });
+ */
+
+const Logger = require('./logger.cjs');
+const logger = new Logger();
+
+/**
+ * Retry an operation with exponential backoff
+ * @param {Function} operation - Async function to retry
+ * @param {Object} options - Retry options
+ * @returns {Promise<any>} - Result of operation
+ */
+async function retry(operation, options = {}) {
+  const {
+    maxRetries = 3,
+    baseDelay = 1000,
+    maxDelay = 30000,
+    jitter = true,
+    shouldRetry = isRetryableError
+  } = options;
+
+  let lastError;
+  let lastAttempt = null;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      lastAttempt = attempt;
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      
+      // Don't retry if error is not retryable or max retries reached
+      if (attempt === maxRetries || !shouldRetry(err)) {
+        logger.error('Operation failed after retries', { 
+          attempts: attempt + 1, 
+          error: err.message 
+        });
+        break;
+      }
+
+      // Calculate delay with exponential backoff and jitter
+      const delay = Math.min(
+        baseDelay * Math.pow(2, attempt),
+        maxDelay
+      );
+      const jitteredDelay = jitter ? delay * (0.5 + Math.random()) : delay;
+
+      logger.warn('Retrying operation', { 
+        attempt: attempt + 1, 
+        maxRetries, 
+        delay: Math.round(jitteredDelay),
+        error: err.message 
+      });
+
+      await new Promise(resolve => setTimeout(resolve, jitteredDelay));
+    }
+  }
+
+  const error = new Error(`Operation failed after ${lastAttempt + 1} attempts: ${lastError.message}`);
+  error.cause = lastError;
+  throw error;
+}
+
+/**
+ * Check if error is retryable
+ * @param {Error} err - Error to check
+ * @returns {boolean} - True if retryable
+ */
+function isRetryableError(err) {
+  const retryableCodes = ['ECONNRESET', 'ETIMEDOUT', 'EAI_AGAIN', 'ENOTFOUND'];
+  const retryableStatus = [429, 500, 502, 503, 504];
+
+  if (err.code && retryableCodes.includes(err.code)) return true;
+  if (err.status && retryableStatus.includes(err.status)) return true;
+  if (err.message?.includes('rate limit')) return true;
+  if (err.message?.includes('timeout')) return true;
+  if (err.message?.includes('network')) return true;
+
+  return false;
+}
+
+/**
+ * Classify error type
+ * @param {Error} err - Error to classify
+ * @returns {string} - Error classification
+ */
+function classifyError(err) {
+  if (isRetryableError(err)) {
+    return 'retryable';
+  }
+  
+  if (err.code === 'ENOENT' || err.code === 'EPERM') {
+    return 'filesystem';
+  }
+  
+  if (err.message?.includes('parse') || err.message?.includes('invalid')) {
+    return 'validation';
+  }
+  
+  return 'unknown';
+}
+
+module.exports = {
+  retry,
+  isRetryableError,
+  classifyError
+};