@axlsdk/axl 0.16.0 → 0.17.0

package/dist/index.js

@@ -22,7 +22,7 @@ function validateStringLengths(value, maxLen, path = "") {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function getBackoffMs(attempt, strategy) {
   switch (strategy) {
@@ -126,17 +126,17 @@ var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 503, 529]);
 var MAX_RETRIES = 2;
 var BASE_DELAY_MS = 1e3;
 function sleep2(ms, signal) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     if (signal?.aborted) {
-      resolve();
+      resolve2();
       return;
     }
-    const timer = setTimeout(resolve, ms);
+    const timer = setTimeout(resolve2, ms);
     signal?.addEventListener(
       "abort",
       () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       },
       { once: true }
     );
@@ -4162,7 +4162,7 @@ ${summaryResponse.content}`
       const controller = new AbortController();
       const parentSignal2 = this.currentSignal;
       const composedSignal = parentSignal2 ? AbortSignal.any([parentSignal2, controller.signal]) : controller.signal;
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         let settled = false;
         let completedCount = 0;
         for (let i = 0; i < n; i++) {
@@ -4176,7 +4176,7 @@ ${summaryResponse.content}`
             if (successCount >= quorum) {
               settled = true;
               controller.abort();
-              resolve(results);
+              resolve2(results);
             } else if (completedCount === n && successCount < quorum) {
               settled = true;
               reject(new QuorumNotMet(quorum, successCount, results));
@@ -4498,7 +4498,7 @@ ${summaryResponse.content}`
     const schema = options?.schema;
     const parentSignal = this.currentSignal;
     const composedSignal = parentSignal ? AbortSignal.any([parentSignal, controller.signal]) : controller.signal;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let settled = false;
       let remaining = fns.length;
       for (const fn of fns) {
@@ -4545,12 +4545,12 @@ ${summaryResponse.content}`
             if (settled) return;
             settled = true;
             controller.abort();
-            resolve(parsed.data);
+            resolve2(parsed.data);
             return;
           }
           settled = true;
           controller.abort();
-          resolve(value);
+          resolve2(value);
         }).catch((err) => {
           if (settled) return;
           if (err instanceof DOMException && err.name === "AbortError") {
@@ -4596,9 +4596,9 @@ ${summaryResponse.content}`
     const controller = quorum ? new AbortController() : void 0;
     const parentSignal = this.currentSignal;
     const mapSignal = controller ? parentSignal ? AbortSignal.any([parentSignal, controller.signal]) : controller.signal : parentSignal;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (items.length === 0) {
-        resolve([]);
+        resolve2([]);
         return;
       }
       const runNext = async () => {
@@ -4619,14 +4619,14 @@ ${summaryResponse.content}`
           if (quorum && successCount >= quorum) {
             settled = true;
             controller?.abort();
-            resolve(results);
+            resolve2(results);
             return;
           }
           if (completedCount === items.length) {
             if (quorum && successCount < quorum) {
               reject(new QuorumNotMet(quorum, successCount, results));
             } else {
-              resolve(results);
+              resolve2(results);
             }
             return;
           }
@@ -4701,8 +4701,8 @@ ${summaryResponse.content}`
       type: "await_human",
       data: { channel: options.channel, prompt: options.prompt }
     });
-    const decision = await new Promise((resolve) => {
-      this.pendingDecisions.set(this.executionId, resolve);
+    const decision = await new Promise((resolve2) => {
+      this.pendingDecisions.set(this.executionId, resolve2);
     });
     this.emitEvent({
       type: "await_human_resolved",
@@ -5954,8 +5954,8 @@ var AxlStream = class _AxlStream extends Readable {
     } });
     let resolvePromise;
     let rejectPromise;
-    this.promise = new Promise((resolve, reject) => {
-      resolvePromise = resolve;
+    this.promise = new Promise((resolve2, reject) => {
+      resolvePromise = resolve2;
       rejectPromise = reject;
     });
     this.bus.on("__resolve", (value) => resolvePromise(value));
@@ -5995,8 +5995,8 @@ var AxlStream = class _AxlStream extends Readable {
         if (self.finished && self.eventQueue.length === 0) {
           return Promise.resolve({ value: void 0, done: true });
         }
-        return new Promise((resolve) => {
-          self.waiters.push(resolve);
+        return new Promise((resolve2) => {
+          self.waiters.push(resolve2);
         });
       },
       [Symbol.asyncIterator]() {
@@ -6315,7 +6315,7 @@ var StdioMcpClient = class {
     }
   }
   sendRequest(method, params, timeoutMs = 3e4) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (!this.process?.stdin?.writable) {
         reject(new Error(`MCP server "${this.name}" is not connected`));
         return;
@@ -6336,7 +6336,7 @@ var StdioMcpClient = class {
       this.pending.set(id, {
         resolve: (value) => {
           clearTimeout(timer);
-          resolve(value);
+          resolve2(value);
         },
         reject: (err) => {
           clearTimeout(timer);
@@ -7887,6 +7887,124 @@ var AxlRuntime = class extends EventEmitter2 {
   }
 };
 
+// src/module-resolve.ts
+function resolveRuntime(mod) {
+  const def = mod.default;
+  return def?.default ?? def ?? mod.runtime;
+}
+function pickDefault(mod) {
+  const def = mod.default;
+  return def?.default ?? def ?? mod.config ?? mod;
+}
+function pickExport(mod, key) {
+  const def = mod.default;
+  return mod[key] ?? def?.[key] ?? def?.default?.[key];
+}
+
+// src/cli-internals.ts
+import { resolve, dirname as dirname2, basename } from "path";
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { pathToFileURL } from "url";
+var CONFIG_CANDIDATES = [
+  "axl.config.mts",
+  "axl.config.ts",
+  "axl.config.mjs",
+  "axl.config.js"
+];
+function findConfig(cwd) {
+  for (const name of CONFIG_CANDIDATES) {
+    const p = resolve(cwd, name);
+    if (existsSync2(p)) return p;
+  }
+  return void 0;
+}
+function needsTsxLoader(filePath) {
+  return /\.[mc]?tsx?$/.test(filePath);
+}
+var tsxRegistered;
+async function ensureTsxRegistered() {
+  if (tsxRegistered !== void 0) return tsxRegistered;
+  try {
+    const mod = await import("tsx/esm/api");
+    if (typeof mod.register === "function") {
+      mod.register();
+      tsxRegistered = true;
+    } else {
+      tsxRegistered = false;
+    }
+  } catch {
+    tsxRegistered = false;
+  }
+  return tsxRegistered;
+}
+async function importModule(filePath, _parentURL) {
+  if (needsTsxLoader(filePath)) {
+    const registered = await ensureTsxRegistered();
+    if (!registered) {
+      throw new Error(
+        `Cannot load TypeScript file ${filePath}: tsx is not installed.
+  Install it as a dev dependency: npm install -D tsx (or pnpm add -D tsx)`
+      );
+    }
+  }
+  return await import(pathToFileURL(filePath).href);
+}
+var MAX_GLOB_DEPTH = 20;
+function expandGlob(pattern, cwd) {
+  if (pattern.includes("**/")) {
+    const sepIdx = pattern.indexOf("**/");
+    const baseDir = resolve(cwd, pattern.slice(0, sepIdx) || ".");
+    const fileGlob2 = pattern.slice(sepIdx + 3) || "*";
+    return findFiles(baseDir, fileGlob2, true);
+  }
+  const dir = resolve(cwd, dirname2(pattern));
+  const fileGlob = basename(pattern);
+  return findFiles(dir, fileGlob, false);
+}
+function findFiles(dir, fileGlob, recursive, depth = 0) {
+  if (depth > MAX_GLOB_DEPTH) return [];
+  const matcher = globToRegex(fileGlob);
+  const results = [];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const full = resolve(dir, entry);
+      try {
+        const stat = statSync(full);
+        if (stat.isFile() && matcher.test(entry)) {
+          results.push(full);
+        } else if (stat.isDirectory() && recursive) {
+          results.push(...findFiles(full, fileGlob, true, depth + 1));
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+async function registerConditions(conditions) {
+  try {
+    const nodeModule = await import("module");
+    const hookCode = [
+      `const extra = ${JSON.stringify(conditions)};`,
+      `export async function resolve(specifier, context, nextResolve) {`,
+      `  return nextResolve(specifier, {`,
+      `    ...context,`,
+      `    conditions: [...new Set([...context.conditions, ...extra])],`,
+      `  });`,
+      `}`
+    ].join("\n");
+    nodeModule.register(`data:text/javascript,${encodeURIComponent(hookCode)}`);
+  } catch {
+    console.warn("Warning: --conditions requires Node.js 20.6+");
+  }
+}
+
 // src/state/redis.ts
 var RedisStore = class _RedisStore {
   constructor(client) {
@@ -8244,6 +8362,7 @@ export {
   AxlRuntime,
   AxlStream,
   BudgetExceededError,
+  CONFIG_CANDIDATES,
   COST_BEARING_LEAF_TYPES,
   GeminiProvider,
   GuardrailError,
@@ -8274,11 +8393,19 @@ export {
   createSpanManager,
   defineConfig,
   eventCostContribution,
+  expandGlob,
   extractJson,
+  findConfig,
+  importModule,
   isCostBearingLeaf,
   isRootLevel,
+  needsTsxLoader,
   parsePartialJson,
+  pickDefault,
+  pickExport,
   redactEvent,
+  registerConditions,
+  resolveRuntime,
   resolveThinkingOptions,
   tool,
   workflow,