@defai.digital/automatosx 6.5.11 → 6.5.12

package/dist/index.js

@@ -1879,16 +1879,18 @@ var init_cli_provider_detector = __esm({
 
 // src/utils/environment.ts
 function isClaudeCodeEnvironment() {
+  const parentProcess = (process.env._ || "").toLowerCase();
+  const comSpec = (process.env.ComSpec || "").toLowerCase();
   return Boolean(
     // Explicit Claude Code indicators
     process.env.CLAUDE_CODE === "true" || process.env.CLAUDE_DESKTOP === "true" || process.env.MCP_SERVER === "true" || // Check parent process name (Unix/Windows)
-    process.env._?.toLowerCase().includes("claude") || process.env.ComSpec?.toLowerCase().includes("claude") || // Check if MCP tools are being used
-    process.env.ANTHROPIC_API_KEY !== void 0
+    parentProcess.includes("claude") || comSpec.includes("claude")
   );
 }
 function isCursorEnvironment() {
+  const parentProcess = (process.env._ || "").toLowerCase();
   return Boolean(
-    process.env.CURSOR === "true" || process.env.CURSOR_IDE === "true" || process.env._?.toLowerCase().includes("cursor")
+    process.env.CURSOR === "true" || process.env.CURSOR_IDE === "true" || parentProcess.includes("cursor")
   );
 }
 function isVSCodeCopilotEnvironment() {
@@ -3036,6 +3038,8 @@ var init_base_provider = __esm({
                 resolved = true;
                 cleanup();
                 resolve12(value);
+              } else {
+                cleanup();
               }
             };
             let sanitizedCommand;
@@ -3267,6 +3271,10 @@ var init_base_provider = __esm({
             const latency = Date.now() - startTime;
             this.updateMetrics(response, latency);
             this.health.consecutiveFailures = 0;
+            if (this.circuitBreakerRecoveryTimeout) {
+              clearTimeout(this.circuitBreakerRecoveryTimeout);
+              this.circuitBreakerRecoveryTimeout = null;
+            }
             try {
               const cost = await this.calculateCostFromTokens(
                 response.tokensUsed,
@@ -9210,39 +9218,47 @@ function validateConfig(config) {
         errors.push(`Execution: defaultTimeout must be <= ${VALIDATION_LIMITS.MAX_TIMEOUT}ms (1 hour max)`);
       }
     }
-    if (!isPositiveInteger(config.execution.retry.maxAttempts)) {
-      errors.push("Execution: retry.maxAttempts must be a positive integer");
-    } else if (config.execution.retry.maxAttempts > 10) {
-      errors.push("Execution: retry.maxAttempts must be <= 10 (reasonable retry limit)");
-    }
-    if (!isNonNegativeInteger(config.execution.retry.initialDelay)) {
-      errors.push("Execution: retry.initialDelay must be a non-negative integer");
-    } else if (config.execution.retry.initialDelay > VALIDATION_LIMITS.MAX_TIMEOUT) {
-      errors.push(`Execution: retry.initialDelay must be <= ${VALIDATION_LIMITS.MAX_TIMEOUT}ms`);
-    }
-    if (!isPositiveInteger(config.execution.retry.maxDelay)) {
-      errors.push("Execution: retry.maxDelay must be a positive integer");
+    if (!config.execution.retry || typeof config.execution.retry !== "object") {
+      errors.push("Execution: retry configuration block is required");
     } else {
-      if (config.execution.retry.maxDelay < config.execution.retry.initialDelay) {
-        errors.push("Execution: retry.maxDelay must be >= initialDelay");
+      if (!isPositiveInteger(config.execution.retry.maxAttempts)) {
+        errors.push("Execution: retry.maxAttempts must be a positive integer");
+      } else if (config.execution.retry.maxAttempts > 10) {
+        errors.push("Execution: retry.maxAttempts must be <= 10 (reasonable retry limit)");
+      }
+      if (!isNonNegativeInteger(config.execution.retry.initialDelay)) {
+        errors.push("Execution: retry.initialDelay must be a non-negative integer");
+      } else if (config.execution.retry.initialDelay > VALIDATION_LIMITS.MAX_TIMEOUT) {
+        errors.push(`Execution: retry.initialDelay must be <= ${VALIDATION_LIMITS.MAX_TIMEOUT}ms`);
+      }
+      if (!isPositiveInteger(config.execution.retry.maxDelay)) {
+        errors.push("Execution: retry.maxDelay must be a positive integer");
+      } else {
+        if (config.execution.retry.maxDelay < config.execution.retry.initialDelay) {
+          errors.push("Execution: retry.maxDelay must be >= initialDelay");
+        }
+        if (config.execution.retry.maxDelay > VALIDATION_LIMITS.MAX_TIMEOUT) {
+          errors.push(`Execution: retry.maxDelay must be <= ${VALIDATION_LIMITS.MAX_TIMEOUT}ms`);
+        }
       }
-      if (config.execution.retry.maxDelay > VALIDATION_LIMITS.MAX_TIMEOUT) {
-        errors.push(`Execution: retry.maxDelay must be <= ${VALIDATION_LIMITS.MAX_TIMEOUT}ms`);
+      if (typeof config.execution.retry.backoffFactor !== "number" || config.execution.retry.backoffFactor < VALIDATION_LIMITS.MIN_BACKOFF_FACTOR) {
+        errors.push(`Execution: retry.backoffFactor must be >= ${VALIDATION_LIMITS.MIN_BACKOFF_FACTOR}`);
+      } else if (config.execution.retry.backoffFactor > VALIDATION_LIMITS.MAX_BACKOFF_FACTOR) {
+        errors.push(`Execution: retry.backoffFactor must be <= ${VALIDATION_LIMITS.MAX_BACKOFF_FACTOR}`);
       }
     }
-    if (typeof config.execution.retry.backoffFactor !== "number" || config.execution.retry.backoffFactor < VALIDATION_LIMITS.MIN_BACKOFF_FACTOR) {
-      errors.push(`Execution: retry.backoffFactor must be >= ${VALIDATION_LIMITS.MIN_BACKOFF_FACTOR}`);
-    } else if (config.execution.retry.backoffFactor > VALIDATION_LIMITS.MAX_BACKOFF_FACTOR) {
-      errors.push(`Execution: retry.backoffFactor must be <= ${VALIDATION_LIMITS.MAX_BACKOFF_FACTOR}`);
-    }
-    if (!isPositiveInteger(config.execution.provider.maxWaitMs)) {
-      errors.push("Execution: provider.maxWaitMs must be a positive integer");
+    if (!config.execution.provider || typeof config.execution.provider !== "object") {
+      errors.push("Execution: provider configuration block is required");
     } else {
-      if (config.execution.provider.maxWaitMs < VALIDATION_LIMITS.MIN_TIMEOUT) {
-        errors.push(`Execution: provider.maxWaitMs must be >= ${VALIDATION_LIMITS.MIN_TIMEOUT}ms`);
-      }
-      if (config.execution.provider.maxWaitMs > VALIDATION_LIMITS.MAX_TIMEOUT) {
-        errors.push(`Execution: provider.maxWaitMs must be <= ${VALIDATION_LIMITS.MAX_TIMEOUT}ms`);
+      if (!isPositiveInteger(config.execution.provider.maxWaitMs)) {
+        errors.push("Execution: provider.maxWaitMs must be a positive integer");
+      } else {
+        if (config.execution.provider.maxWaitMs < VALIDATION_LIMITS.MIN_TIMEOUT) {
+          errors.push(`Execution: provider.maxWaitMs must be >= ${VALIDATION_LIMITS.MIN_TIMEOUT}ms`);
+        }
+        if (config.execution.provider.maxWaitMs > VALIDATION_LIMITS.MAX_TIMEOUT) {
+          errors.push(`Execution: provider.maxWaitMs must be <= ${VALIDATION_LIMITS.MAX_TIMEOUT}ms`);
+        }
       }
     }
     if (config.execution.maxConcurrentAgents !== void 0) {
@@ -9993,6 +10009,12 @@ function validateProvider(name, provider) {
       message: "priority must be a number",
       value: provider.priority
     });
+  } else if (!Number.isInteger(provider.priority)) {
+    errors.push({
+      path: `${basePath}.priority`,
+      message: "priority must be an integer (no fractional values)",
+      value: provider.priority
+    });
   } else if (provider.priority < 1) {
     errors.push({
       path: `${basePath}.priority`,
@@ -10006,6 +10028,12 @@ function validateProvider(name, provider) {
       message: "timeout must be a number",
       value: provider.timeout
     });
+  } else if (!Number.isInteger(provider.timeout)) {
+    errors.push({
+      path: `${basePath}.timeout`,
+      message: "timeout must be an integer (no fractional values)",
+      value: provider.timeout
+    });
   } else if (provider.timeout < 1e3) {
     errors.push({
       path: `${basePath}.timeout`,
@@ -13957,6 +13985,10 @@ var RouterTraceLogger = class {
   enabled;
   autoFlush;
   streamInitializing = false;
+  // FIXED (v6.5.12 Bug #123): Store event handler references for cleanup
+  exitHandler = () => this.close();
+  sigintHandler = () => this.close();
+  sigtermHandler = () => this.close();
   constructor(options) {
     this.traceFile = join(options.workspacePath, ".automatosx/logs/router.trace.jsonl");
     this.enabled = options.enabled ?? true;
@@ -13967,9 +13999,9 @@ var RouterTraceLogger = class {
         mkdirSync(logDir, { recursive: true });
       }
     }
-    process.on("exit", () => this.close());
-    process.on("SIGINT", () => this.close());
-    process.on("SIGTERM", () => this.close());
+    process.on("exit", this.exitHandler);
+    process.on("SIGINT", this.sigintHandler);
+    process.on("SIGTERM", this.sigtermHandler);
   }
   /**
    * Log a trace event
@@ -14151,8 +14183,15 @@ var RouterTraceLogger = class {
   }
   /**
    * Flush and close the trace file
+   *
+   * FIXED (v6.5.12 Bug #123): Remove process event listeners to prevent memory leak
+   * Without cleanup, each RouterTraceLogger instance leaves 3 event listeners attached
+   * to the process object, preventing garbage collection.
    */
   close() {
+    process.removeListener("exit", this.exitHandler);
+    process.removeListener("SIGINT", this.sigintHandler);
+    process.removeListener("SIGTERM", this.sigtermHandler);
     if (this.stream) {
       this.stream.end();
       this.stream = void 0;
@@ -15172,7 +15211,7 @@ var Router = class {
           const reason = request.spec?.policy ? "policy-based selection" : "priority-based selection";
           const specContext = request.spec ? {
             specId: request.spec.metadata?.id,
-            taskId: request.spec.taskId
+            taskId: request.spec?.taskId
           } : void 0;
           this.tracer.logSelection(candidateNames, provider.name, reason, void 0, specContext);
         }
@@ -15888,6 +15927,7 @@ var MemoryManager = class _MemoryManager {
         accessCount: 0
       };
     } catch (error) {
+      if (error instanceof MemoryError) throw error;
       throw new MemoryError(
         `Failed to add memory entry: ${error.message}`,
         "DATABASE_ERROR"
@@ -17209,16 +17249,17 @@ var SessionManager = class _SessionManager {
     if (session.metadata.tasks.length > this.MAX_TASKS_PER_SESSION) {
       const completedTasks = session.metadata.tasks.filter((t) => t.status === "completed" || t.status === "failed");
       const runningTasks = session.metadata.tasks.filter((t) => t.status === "running" || t.status === "pending");
-      const tasksToKeep = this.MAX_TASKS_PER_SESSION - runningTasks.length;
+      const oldTaskCount = session.metadata.tasks.length;
+      const tasksToKeep = Math.max(0, this.MAX_TASKS_PER_SESSION - runningTasks.length);
       const recentCompleted = completedTasks.sort((a, b) => {
         const aTime = a.completedAt || a.startedAt;
         const bTime = b.completedAt || b.startedAt;
         return bTime.localeCompare(aTime);
-      }).slice(0, Math.max(0, tasksToKeep));
+      }).slice(0, tasksToKeep);
       session.metadata.tasks = [...runningTasks, ...recentCompleted];
       logger.debug("Cleaned up old tasks", {
         sessionId,
-        removed: session.metadata.tasks.length - (runningTasks.length + recentCompleted.length),
+        removed: oldTaskCount - session.metadata.tasks.length,
         remaining: session.metadata.tasks.length
       });
     }
@@ -17655,6 +17696,11 @@ var SessionManager = class _SessionManager {
         throw renameError;
       }
     } catch (error) {
+      const tempPath = `${this.persistencePath}.tmp`;
+      try {
+        await unlink(tempPath);
+      } catch (unlinkError) {
+      }
       logger.error("Failed to save sessions to persistence", {
         path: normalizePath(this.persistencePath),
         error: error.message
@@ -19747,13 +19793,15 @@ var DelegationParser = class {
     const lastNewline = before.lastIndexOf("\n");
     if (lastDoubleQuote > lastNewline) {
       const closingDoubleQuote = after.indexOf('"');
-      if (closingDoubleQuote !== -1 && closingDoubleQuote < after.indexOf("\n\n")) {
+      const blankLinePos = after.indexOf("\n\n");
+      if (closingDoubleQuote !== -1 && (blankLinePos === -1 || closingDoubleQuote < blankLinePos)) {
         return true;
       }
     }
     if (lastSingleQuote > lastNewline) {
       const closingSingleQuote = after.indexOf("'");
-      if (closingSingleQuote !== -1 && closingSingleQuote < after.indexOf("\n\n")) {
+      const blankLinePos = after.indexOf("\n\n");
+      if (closingSingleQuote !== -1 && (blankLinePos === -1 || closingSingleQuote < blankLinePos)) {
         return true;
       }
     }
@@ -19792,9 +19840,11 @@ var DelegationParser = class {
     if (testCodePatterns.test(before) || testCodePatterns.test(after)) {
       return true;
     }
-    const combinedContext = before.slice(-100) + after.slice(0, 100);
+    const beforeSlice = before.length > 0 ? before.slice(-Math.min(100, before.length)) : "";
+    const afterSlice = after.length > 0 ? after.slice(0, Math.min(100, after.length)) : "";
+    const combinedContext = beforeSlice + afterSlice;
     const stringLiteralPattern = /['"`][^'"`]{0,100}@[a-zA-Z0-9-_]+[^'"`]{0,100}['"`]/;
-    if (stringLiteralPattern.test(combinedContext)) {
+    if (combinedContext.length > 0 && stringLiteralPattern.test(combinedContext)) {
       return true;
     }
     return false;
@@ -25004,6 +25054,21 @@ var ProgressChannel = class {
       this.processing = false;
     }
   }
+  /**
+   * Cleanup channel and clear pending timers
+   *
+   * FIXED (v6.5.12 Bug #122): Added cleanup method to prevent timer leaks
+   * Clears pending timeout and removes all listeners to allow proper garbage collection.
+   */
+  destroy() {
+    if (this.processQueueTimeout) {
+      clearTimeout(this.processQueueTimeout);
+      this.processQueueTimeout = void 0;
+    }
+    this.listeners.clear();
+    this.eventQueue = [];
+    this.processing = false;
+  }
 };
 
 // src/cli/renderers/progress-renderer.ts
@@ -27881,7 +27946,8 @@ async function getLatestVersion() {
   return stdout.trim();
 }
 function isNewer(a, b) {
-  const parseVersion = (v) => v.split(".").map(Number);
+  const stripPrerelease = (v) => v.split("-")[0] || v;
+  const parseVersion = (v) => stripPrerelease(v).split(".").map(Number);
   const [aMajor = 0, aMinor = 0, aPatch = 0] = parseVersion(a);
   const [bMajor = 0, bMinor = 0, bPatch = 0] = parseVersion(b);
   if (aMajor !== bMajor) return aMajor > bMajor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defai.digital/automatosx",
-  "version": "6.5.11",
+  "version": "6.5.12",
   "description": "AI Agent Orchestration Platform",
   "type": "module",
   "publishConfig": {