@defai.digital/automatosx 11.2.8 → 11.3.0

package/dist/mcp/index.js

@@ -7,13 +7,13 @@ import { existsSync, readFileSync, promises, mkdirSync, createWriteStream, write
 import Database2 from 'better-sqlite3';
 import { glob } from 'glob';
 import { spawn, spawnSync } from 'child_process';
-import { z } from 'zod';
+import { z, ZodError } from 'zod';
 import chalk4 from 'chalk';
 import ora2 from 'ora';
 import readline, { createInterface } from 'readline';
+import { Mutex } from 'async-mutex';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
-import { Mutex } from 'async-mutex';
 import os2, { cpus } from 'os';
 import { load } from 'js-yaml';
 import { EventEmitter } from 'events';
@@ -2277,6 +2277,15 @@ var init_base_provider = __esm({
         "test-provider"
         // For unit tests
       ];
+      /** Environment variables to force non-interactive CLI mode */
+      static NON_INTERACTIVE_ENV = {
+        TERM: "dumb",
+        NO_COLOR: "1",
+        FORCE_COLOR: "0",
+        CI: "true",
+        NO_UPDATE_NOTIFIER: "1",
+        DEBIAN_FRONTEND: "noninteractive"
+      };
       config;
       logger = logger;
       health;
@@ -2369,19 +2378,7 @@ var init_base_provider = __esm({
             shell: true,
             // Auto-detects: cmd.exe on Windows, /bin/sh on Unix
             timeout: this.config.timeout || 12e4,
-            env: {
-              ...process.env,
-              // Force non-interactive mode for CLIs
-              TERM: "dumb",
-              NO_COLOR: "1",
-              // Disable TTY checks for codex and other CLIs
-              FORCE_COLOR: "0",
-              CI: "true",
-              // Many CLIs disable TTY checks in CI mode
-              NO_UPDATE_NOTIFIER: "1",
-              // Disable interactive prompts
-              DEBIAN_FRONTEND: "noninteractive"
-            }
+            env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
           let stderr = "";
@@ -2531,22 +2528,14 @@ var init_base_provider = __esm({
           });
           const child = spawn(cliCommand, commandArgs, {
             timeout: this.config.timeout || 12e4,
-            env: {
-              ...process.env,
-              // Force non-interactive mode for CLIs
-              TERM: "dumb",
-              NO_COLOR: "1",
-              FORCE_COLOR: "0",
-              CI: "true",
-              NO_UPDATE_NOTIFIER: "1",
-              DEBIAN_FRONTEND: "noninteractive"
-            }
+            env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
           let stderr = "";
           let timeoutId = null;
           let forceKillTimer = null;
           let readlineInterface = null;
+          let stderrInterface = null;
           const streamingEnabled = process.env.AUTOMATOSX_SHOW_PROVIDER_OUTPUT === "true";
           const debugMode = process.env.AUTOMATOSX_DEBUG === "true";
           const verbosity = VerbosityManager.getInstance();
@@ -2591,7 +2580,7 @@ var init_base_provider = __esm({
             });
           }
           if (child.stderr) {
-            const stderrInterface = readline.createInterface({
+            stderrInterface = readline.createInterface({
               input: child.stderr,
               crlfDelay: Infinity
             });
@@ -2607,6 +2596,13 @@ var init_base_provider = __esm({
                 }
               }
             });
+            stderrInterface.on("error", (error) => {
+              if (error.message !== "Readable stream already read") {
+                logger.debug("Stderr readline error (non-fatal)", {
+                  error: error.message
+                });
+              }
+            });
           }
           const cleanup = () => {
             if (timeoutId) {
@@ -2625,22 +2621,35 @@ var init_base_provider = __esm({
                 readlineInterface = null;
               }
             }
+            if (stderrInterface) {
+              try {
+                stderrInterface.close();
+              } catch (error) {
+              } finally {
+                stderrInterface = null;
+              }
+            }
           };
           child.on("close", (code, signal) => {
             cleanup();
             if (stderr) {
               logger.debug(`${cliCommand} CLI stderr output`, { stderr: stderr.trim() });
             }
-            if (code === 0) {
+            if ((code === 0 || code === null) && !signal) {
               if (progressParser) {
                 progressParser.succeed(`${cliCommand} completed successfully`);
               }
               resolve5({ stdout, stderr });
+            } else if (signal) {
+              if (progressParser) {
+                progressParser.fail(`${cliCommand} killed by signal ${signal}`);
+              }
+              reject(new Error(`${cliCommand} CLI killed by signal ${signal}. stderr: ${stderr || "none"}`));
             } else {
               if (progressParser) {
                 progressParser.fail(`${cliCommand} failed with code ${code}`);
               }
-              reject(new Error(`${cliCommand} CLI exited with code ${code}${signal ? ` (signal: ${signal})` : ""}. stderr: ${stderr || "none"}`));
+              reject(new Error(`${cliCommand} CLI exited with code ${code}. stderr: ${stderr || "none"}`));
             }
           });
           child.on("error", (error) => {
@@ -2676,8 +2685,18 @@ var init_base_provider = __esm({
       /**
        * Check if CLI is available - Template method pattern
        * Uses getCLICommand() to determine which CLI to check
+       *
+       * v11.2.9 Fix: Always return true in mock mode (AX_MOCK_PROVIDERS=true)
+       * This allows integration tests in CI to run without installing actual provider CLIs
        */
       async checkCLIAvailable() {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          logger.debug(`${this.getCLICommand()} CLI availability check (mock mode)`, {
+            available: true,
+            mockMode: true
+          });
+          return true;
+        }
         try {
           const cliCommand = this.getCLICommand();
           const result = findOnPath(cliCommand);
@@ -3596,8 +3615,6 @@ var init_cli_wrapper = __esm({
     };
   }
 });
-
-// src/integrations/openai-codex/sdk-adapter.ts
 var CodexSdkAdapter;
 var init_sdk_adapter = __esm({
   "src/integrations/openai-codex/sdk-adapter.ts"() {
@@ -3610,6 +3627,8 @@ var init_sdk_adapter = __esm({
       sdkModule = null;
       options;
       initialized = false;
+      initMutex = new Mutex();
+      // v11.2.8: Prevent race condition in ensureInitialized
       constructor(options = {}) {
         this.options = {
           streamingEnabled: true,
@@ -3704,18 +3723,20 @@ var init_sdk_adapter = __esm({
         return this.activeThread;
       }
       async ensureInitialized() {
-        if (this.initialized) return;
-        try {
-          this.sdkModule = await import('@openai/codex-sdk');
-          this.codex = new this.sdkModule.Codex();
-          this.initialized = true;
-          logger.info("Codex SDK initialized");
-        } catch (error) {
-          throw new CodexError(
-            "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
-            "Codex SDK not available. Install with: npm install @openai/codex-sdk"
-          );
-        }
+        return this.initMutex.runExclusive(async () => {
+          if (this.initialized) return;
+          try {
+            this.sdkModule = await import('@openai/codex-sdk');
+            this.codex = new this.sdkModule.Codex();
+            this.initialized = true;
+            logger.info("Codex SDK initialized");
+          } catch (error) {
+            throw new CodexError(
+              "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
+              "Codex SDK not available. Install with: npm install @openai/codex-sdk"
+            );
+          }
+        });
       }
       async destroy() {
         this.activeThread = null;
@@ -5229,7 +5250,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.2.8"
+  "version": "11.3.0"
 };
 
 // src/core/config/schemas.ts
@@ -6478,6 +6499,8 @@ var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
   getManualOverride() {
     if (this.manualOverride && this.manualOverride.expiresAtMs) {
       if (Date.now() >= this.manualOverride.expiresAtMs) {
+        this.manualOverride;
+        this.manualOverride = void 0;
         void this.clearManualOverride();
         return void 0;
       }
@@ -6972,19 +6995,33 @@ var ProviderMetricsTracker = class extends EventEmitter {
     const p50 = getPercentile(latencies, 50);
     const p95 = getPercentile(latencies, 95);
     const p99 = getPercentile(latencies, 99);
-    const successful = records.filter((r) => r.success);
-    const failed = records.filter((r) => !r.success);
-    const stopFinishes = successful.filter((r) => r.finishReason === "stop");
-    const lengthFinishes = successful.filter((r) => r.finishReason === "length");
-    const errorFinishes = records.filter((r) => r.finishReason === "error");
-    const successRate = successful.length / records.length;
-    const properStopRate = successful.length > 0 ? stopFinishes.length / successful.length : 0;
+    let successCount = 0;
+    let failCount = 0;
+    let stopFinishCount = 0;
+    let lengthFinishCount = 0;
+    let errorFinishCount = 0;
+    let lastSuccessTimestamp = 0;
+    let lastFailureTimestamp = 0;
+    for (const r of records) {
+      if (r.success) {
+        successCount++;
+        lastSuccessTimestamp = r.timestamp;
+        if (r.finishReason === "stop") stopFinishCount++;
+        else if (r.finishReason === "length") lengthFinishCount++;
+      } else {
+        failCount++;
+        lastFailureTimestamp = r.timestamp;
+      }
+      if (r.finishReason === "error") errorFinishCount++;
+    }
+    const successRate = successCount / records.length;
+    const properStopRate = successCount > 0 ? stopFinishCount / successCount : 0;
     const totalCost = records.reduce((sum, r) => sum + r.costUsd, 0);
     const avgCostPerRequest = totalCost / records.length;
     const totalTokens = records.reduce((sum, r) => sum + r.totalTokens, 0);
     const avgCostPer1M = totalTokens > 0 ? totalCost / totalTokens * 1e6 : 0;
-    const lastSuccess = successful.length > 0 ? successful[successful.length - 1].timestamp : 0;
-    const lastFailure = failed.length > 0 ? failed[failed.length - 1].timestamp : 0;
+    const lastSuccess = lastSuccessTimestamp;
+    const lastFailure = lastFailureTimestamp;
     let consecutiveFailures = 0;
     for (let i = records.length - 1; i >= 0; i--) {
       if (!records[i].success) {
@@ -7007,12 +7044,12 @@ var ProviderMetricsTracker = class extends EventEmitter {
       },
       quality: {
         totalRequests: records.length,
-        successfulRequests: successful.length,
-        failedRequests: failed.length,
+        successfulRequests: successCount,
+        failedRequests: failCount,
         successRate,
-        stopFinishes: stopFinishes.length,
-        lengthFinishes: lengthFinishes.length,
-        errorFinishes: errorFinishes.length,
+        stopFinishes: stopFinishCount,
+        lengthFinishes: lengthFinishCount,
+        errorFinishes: errorFinishCount,
         properStopRate
       },
       cost: {
@@ -7121,7 +7158,7 @@ var ProviderMetricsTracker = class extends EventEmitter {
    * v9.0.2: Added score caching to reduce redundant calculations
    */
   async calculateScore(provider, weights, allProviders, healthMultiplier = 1) {
-    const cacheKey = `${provider}-${JSON.stringify(weights)}-${healthMultiplier}`;
+    const cacheKey = `${provider}-${weights.cost}-${weights.latency}-${weights.quality}-${weights.availability}-${healthMultiplier}`;
     const cached = this.scoreCache.get(cacheKey);
     const currentRequestCount = this.getRequestCount(provider);
     if (cached) {
@@ -8285,8 +8322,7 @@ var Router = class {
         }
       }
       if (limitedProviders2.length === allProviders2.length && limitedProviders2.length > 0) {
-        const soonestReset = Math.min(...limitedProviders2.map((p) => p.resetAtMs));
-        throw ProviderError.allProvidersLimited(limitedProviders2, soonestReset);
+        throw ProviderError.allProvidersLimited(limitedProviders2, this.getSoonestLimitReset(limitedProviders2));
       }
       throw ProviderError.noAvailableProviders();
     }
@@ -8692,8 +8728,7 @@ var Router = class {
       }
     }
     if (limitedProviders.length === allProviders.length && limitedProviders.length > 0) {
-      const soonestReset = Math.min(...limitedProviders.map((p) => p.resetAtMs));
-      throw ProviderError.allProvidersLimited(limitedProviders, soonestReset);
+      throw ProviderError.allProvidersLimited(limitedProviders, this.getSoonestLimitReset(limitedProviders));
     }
     const errorDetails = {
       lastError: lastError?.message,
@@ -8927,6 +8962,16 @@ Run 'ax doctor' to diagnose provider setup.` : "";
       })
     };
   }
+  /**
+   * Calculate the soonest reset time from limited providers
+   * v11.2.8: Added guard against empty array (Math.min on empty array returns Infinity)
+   */
+  getSoonestLimitReset(limitedProviders) {
+    if (limitedProviders.length === 0) {
+      return Date.now() + 6e4;
+    }
+    return Math.min(...limitedProviders.map((p) => p.resetAtMs));
+  }
 };
 
 // src/core/memory/lazy-manager.ts
@@ -10760,8 +10805,6 @@ z.object({
   limit: z.number().int().positive().max(1e4).optional(),
   offset: z.number().int().nonnegative().optional()
 }).strict();
-
-// src/core/session/manager.ts
 var SessionManager = class _SessionManager {
   /** Active sessions (in-memory, keyed by session ID) */
   activeSessions = /* @__PURE__ */ new Map();
@@ -10834,8 +10877,9 @@ var SessionManager = class _SessionManager {
       try {
         SessionManagerConfigSchema.parse(config);
       } catch (error) {
+        const message = error instanceof ZodError ? error.message : String(error);
         throw new SessionError(
-          `Invalid session manager config: ${error.message}`,
+          `Invalid session manager config: ${message}`,
           void 0,
           "invalid_configuration"
         );
@@ -12236,8 +12280,8 @@ var ProjectContextLoader = class {
     const projectMatch = markdown.match(/>\s*Project:\s*(.+?)$/im);
     if (projectMatch && projectMatch[1]) {
       const parts = projectMatch[1].trim().split(/\s+v/);
-      metadata.name = parts[0];
-      if (parts[1]) {
+      metadata.name = parts[0] || "";
+      if (parts.length > 1 && parts[1]) {
         metadata.version = parts[1];
       }
     }

package/examples/abilities/our-architecture-decisions.md

@@ -25,7 +25,7 @@
 
 **Rationale:**
 
-- Node.js 20+ has first-class ESM support
+- Node.js 24+ has first-class ESM support
 - Better tree-shaking and bundle optimization
 - Modern standards compliance
 

package/examples/abilities/our-project-structure.md

@@ -137,7 +137,7 @@ import type { Provider } from '../types/provider.js';
 - `index.js.map` - Source map
 - `index.d.ts` - Type definitions
 
-**Bundle target:** ESM, Node 20+, <250KB target
+**Bundle target:** ESM, Node 24+, <250KB target
 
 ## Workspace Structure
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defai.digital/automatosx",
-  "version": "11.2.8",
+  "version": "11.3.0",
   "description": "Provider-agnostic AI orchestration platform with 20+ specialized agents, persistent memory, and multi-provider routing for Claude Code, Gemini CLI, Codex CLI, and ax-cli",
   "type": "module",
   "publishConfig": {