agent-relay 4.0.31 → 4.0.33

package/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateConditions.js

@@ -2,21 +2,25 @@ import { debugId, toDebugString } from "../debug";
 import { evaluateCondition } from "./evaluateCondition";
 export const evaluateConditions = (conditions = [], options) => {
     const conditionsReferenceRecord = {};
+    const conditionOptions = {
+        ...options,
+        referenceRecord: { ...options.referenceRecord },
+    };
+    let didAssign = false;
     for (const condition of conditions) {
-        const { result, toAssign } = evaluateCondition(condition, {
-            ...options,
-            referenceRecord: {
-                ...options.referenceRecord,
-                ...conditionsReferenceRecord,
-            },
-        });
+        const { result, toAssign } = evaluateCondition(condition, conditionOptions);
         if (!result) {
             return { result };
         }
         if (toAssign) {
+            didAssign = true;
             conditionsReferenceRecord[toAssign.name] = toAssign.value;
+            conditionOptions.referenceRecord[toAssign.name] = toAssign.value;
             options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
         }
     }
-    return { result: true, referenceRecord: conditionsReferenceRecord };
+    if (didAssign) {
+        return { result: true, referenceRecord: conditionsReferenceRecord };
+    }
+    return { result: true };
 };

package/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateEndpointRule.js

@@ -9,19 +9,20 @@ export const evaluateEndpointRule = (endpointRule, options) => {
     if (!result) {
         return;
     }
-    const endpointRuleOptions = {
-        ...options,
-        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-    };
+    const endpointRuleOptions = referenceRecord
+        ? {
+            ...options,
+            referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+        }
+        : options;
     const { url, properties, headers } = endpoint;
     options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);
-    return {
-        ...(headers != undefined && {
-            headers: getEndpointHeaders(headers, endpointRuleOptions),
-        }),
-        ...(properties != undefined && {
-            properties: getEndpointProperties(properties, endpointRuleOptions),
-        }),
-        url: getEndpointUrl(url, endpointRuleOptions),
-    };
+    const endpointToReturn = { url: getEndpointUrl(url, endpointRuleOptions) };
+    if (headers != null) {
+        endpointToReturn.headers = getEndpointHeaders(headers, endpointRuleOptions);
+    }
+    if (properties != null) {
+        endpointToReturn.properties = getEndpointProperties(properties, endpointRuleOptions);
+    }
+    return endpointToReturn;
 };

package/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateErrorRule.js

@@ -7,8 +7,11 @@ export const evaluateErrorRule = (errorRule, options) => {
     if (!result) {
         return;
     }
-    throw new EndpointError(evaluateExpression(error, "Error", {
-        ...options,
-        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-    }));
+    const errorRuleOptions = referenceRecord
+        ? {
+            ...options,
+            referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+        }
+        : options;
+    throw new EndpointError(evaluateExpression(error, "Error", errorRuleOptions));
 };

package/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js

@@ -26,17 +26,19 @@ export const callFunction = ({ fn, argv }, options) => {
             evaluatedArgs[i] = group.evaluateExpression(arg, "arg", options);
         }
     }
-    if (fn.includes(".")) {
-        const fnSegments = fn.split(".");
-        if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
-            return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
+    const namespaceSeparatorIndex = fn.indexOf(".");
+    if (namespaceSeparatorIndex !== -1) {
+        const namespaceFunctions = customEndpointFunctions[fn.slice(0, namespaceSeparatorIndex)];
+        const customFunction = namespaceFunctions?.[fn.slice(namespaceSeparatorIndex + 1)];
+        if (typeof customFunction === "function") {
+            return customFunction(...evaluatedArgs);
         }
     }
-    if (typeof endpointFunctions[fn] !== "function") {
-        throw new Error(`function ${fn} not loaded in endpointFunctions.`);
-    }
     const callable = endpointFunctions[fn];
-    return callable(...evaluatedArgs);
+    if (typeof callable === "function") {
+        return callable(...evaluatedArgs);
+    }
+    throw new Error(`function ${fn} not loaded in endpointFunctions.`);
 };
 export const group = {
     evaluateExpression,

package/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js

@@ -31,10 +31,10 @@ export const evaluateTreeRule = (treeRule, options) => {
     if (!result) {
         return;
     }
-    return group.evaluateRules(rules, {
-        ...options,
-        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-    });
+    const treeRuleOptions = referenceRecord
+        ? { ...options, referenceRecord: { ...options.referenceRecord, ...referenceRecord } }
+        : options;
+    return group.evaluateRules(rules, treeRuleOptions);
 };
 export const group = {
     evaluateRules,

package/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointHeaders.js

@@ -1,12 +1,12 @@
 import { EndpointError } from "../types";
 import { evaluateExpression } from "./evaluateExpression";
-export const getEndpointHeaders = (headers, options) => Object.entries(headers ?? {}).reduce((acc, [headerKey, headerVal]) => ({
-    ...acc,
-    [headerKey]: headerVal.map((headerValEntry) => {
+export const getEndpointHeaders = (headers, options) => Object.entries(headers ?? {}).reduce((acc, [headerKey, headerVal]) => {
+    acc[headerKey] = headerVal.map((headerValEntry) => {
         const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
         if (typeof processedExpr !== "string") {
             throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
         }
         return processedExpr;
-    }),
-}), {});
+    });
+    return acc;
+}, {});

package/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js

@@ -1,9 +1,9 @@
 import { EndpointError } from "../types";
 import { evaluateTemplate } from "./evaluateTemplate";
-export const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
-    ...acc,
-    [propertyKey]: group.getEndpointProperty(propertyVal, options),
-}), {});
+export const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => {
+    acc[propertyKey] = group.getEndpointProperty(propertyVal, options);
+    return acc;
+}, {});
 export const getEndpointProperty = (property, options) => {
     if (Array.isArray(property)) {
         return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));

package/node_modules/@smithy/util-endpoints/dist-types/types/shared.d.ts

@@ -1,4 +1,4 @@
-import type { EndpointARN, EndpointPartition, Logger } from "@smithy/types";
+import type { EndpointARN, EndpointPartition, EndpointURL, Logger } from "@smithy/types";
 export type ReferenceObject = {
     ref: string;
 };
@@ -7,9 +7,9 @@ export type FunctionObject = {
     argv: FunctionArgv;
 };
 export type FunctionArgv = Array<Expression | boolean | number>;
-export type FunctionReturn = string | boolean | number | EndpointARN | EndpointPartition | {
+export type FunctionReturn = string | boolean | number | EndpointARN | EndpointPartition | EndpointURL | {
     [key: string]: FunctionReturn;
-} | null;
+} | Array<FunctionReturn> | null;
 export type ConditionObject = FunctionObject & {
     assign?: string;
 };

package/node_modules/@smithy/util-endpoints/dist-types/utils/endpointFunctions.d.ts

@@ -1,15 +1,2 @@
-import { coalesce, ite, split } from "../lib";
-export declare const endpointFunctions: {
-    booleanEquals: (value1: boolean, value2: boolean) => boolean;
-    coalesce: typeof coalesce;
-    getAttr: (value: import("../lib").GetAttrValue, path: string) => import("../lib").GetAttrValue;
-    isSet: (value: unknown) => value is {};
-    isValidHostLabel: (value: string, allowSubDomains?: boolean) => boolean;
-    ite: typeof ite;
-    not: (value: boolean) => boolean;
-    parseURL: (value: string | URL | import("@smithy/types").Endpoint) => import("@smithy/types").EndpointURL | null;
-    split: typeof split;
-    stringEquals: (value1: string, value2: string) => boolean;
-    substring: (input: string, start: number, stop: number, reverse: boolean) => string | null;
-    uriEncode: (value: string) => string;
-};
+import type { EndpointFunctions } from "../types";
+export declare const endpointFunctions: EndpointFunctions;

package/node_modules/@smithy/util-endpoints/dist-types/utils/evaluateCondition.d.ts

@@ -1,8 +1,11 @@
 import type { ConditionObject, EvaluateOptions } from "../types";
-export declare const evaluateCondition: ({ assign, ...fnArgs }: ConditionObject, options: EvaluateOptions) => {
-    toAssign?: {
+export declare const evaluateCondition: (condition: ConditionObject, options: EvaluateOptions) => {
+    result: boolean;
+    toAssign: {
         name: string;
         value: import("../types").FunctionReturn;
-    } | undefined;
+    };
+} | {
     result: boolean;
+    toAssign?: undefined;
 };

package/node_modules/@smithy/util-endpoints/dist-types/utils/evaluateConditions.d.ts

@@ -1,8 +1,8 @@
 import type { ConditionObject, EvaluateOptions, FunctionReturn } from "../types";
 export declare const evaluateConditions: (conditions: ConditionObject[] | undefined, options: EvaluateOptions) => {
-    result: false;
-    referenceRecord?: undefined;
-} | {
     result: boolean;
     referenceRecord: Record<string, FunctionReturn>;
+} | {
+    result: boolean;
+    referenceRecord?: undefined;
 };

package/node_modules/@smithy/util-endpoints/dist-types/utils/getEndpointHeaders.d.ts

@@ -1,2 +1,2 @@
 import type { EndpointObjectHeaders, EvaluateOptions } from "../types";
-export declare const getEndpointHeaders: (headers: EndpointObjectHeaders, options: EvaluateOptions) => {};
+export declare const getEndpointHeaders: (headers: EndpointObjectHeaders, options: EvaluateOptions) => Record<string, string[]>;

package/node_modules/@smithy/util-endpoints/dist-types/utils/getEndpointProperties.d.ts

@@ -1,8 +1,8 @@
 import type { EndpointObjectProperty } from "@smithy/types";
 import type { EndpointObjectProperties, EvaluateOptions } from "../types";
-export declare const getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => {};
+export declare const getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => Record<string, EndpointObjectProperty>;
 export declare const getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
 export declare const group: {
     getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
-    getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => {};
+    getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => Record<string, EndpointObjectProperty>;
 };

package/node_modules/@smithy/util-endpoints/dist-types/utils/getReferenceValue.d.ts

@@ -1,4 +1,4 @@
 import type { EvaluateOptions, ReferenceObject } from "../types";
-export declare const getReferenceValue: ({ ref }: ReferenceObject, options: EvaluateOptions) => string | number | boolean | import("@smithy/types").EndpointPartition | import("@smithy/types").EndpointARN | {
+export declare const getReferenceValue: ({ ref }: ReferenceObject, options: EvaluateOptions) => string | number | boolean | import("@smithy/types").EndpointPartition | import("@smithy/types").EndpointARN | import("@smithy/types").EndpointURL | {
     [key: string]: import("../types").FunctionReturn;
-};
+} | import("../types").FunctionReturn[];

package/node_modules/@smithy/util-endpoints/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/util-endpoints",
-  "version": "3.4.1",
+  "version": "3.4.2",
   "description": "Utilities to help with endpoint resolution.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",

package/node_modules/@smithy/util-retry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/util-retry",
-  "version": "4.3.2",
+  "version": "4.3.3",
   "description": "Shared retry utilities to be used in middleware packages.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -30,7 +30,7 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/service-error-classification": "^4.2.14",
+    "@smithy/service-error-classification": "^4.3.0",
     "@smithy/types": "^4.14.1",
     "tslib": "^2.6.2"
   },

package/node_modules/@smithy/util-stream/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/util-stream",
-  "version": "4.5.23",
+  "version": "4.5.24",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
     "build:es:cjs": "yarn g:tsc -p tsconfig.es.json && node ../../scripts/inline util-stream",
@@ -29,7 +29,7 @@
   "sideEffects": false,
   "dependencies": {
     "@smithy/fetch-http-handler": "^5.3.17",
-    "@smithy/node-http-handler": "^4.5.3",
+    "@smithy/node-http-handler": "^4.6.0",
     "@smithy/types": "^4.14.1",
     "@smithy/util-base64": "^4.3.2",
     "@smithy/util-buffer-from": "^4.2.2",

package/node_modules/agent-trajectories/dist/{chunk-2XT3DOJC.js → chunk-27AQPWHK.js}

@@ -666,8 +666,16 @@ function formatTime(isoString) {
 }
 
 // src/storage/file.ts
+import { randomUUID } from "crypto";
 import { existsSync } from "fs";
-import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
+import {
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  unlink,
+  writeFile
+} from "fs/promises";
 import { join } from "path";
 function expandPath(path) {
   if (path.startsWith("~")) {
@@ -675,6 +683,16 @@ function expandPath(path) {
   }
   return path;
 }
+var indexLocks = /* @__PURE__ */ new Map();
+function withIndexLock(path, task) {
+  const prev = indexLocks.get(path) ?? Promise.resolve();
+  const next = prev.then(task, task);
+  indexLocks.set(
+    path,
+    next.catch(() => void 0)
+  );
+  return next;
+}
 var FileStorage = class {
   baseDir;
   trajectoriesDir;
@@ -701,10 +719,10 @@ var FileStorage = class {
     await mkdir(this.activeDir, { recursive: true });
     await mkdir(this.completedDir, { recursive: true });
     if (!existsSync(this.indexPath)) {
-      await this.saveIndex({
-        version: 1,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-        trajectories: {}
+      await withIndexLock(this.indexPath, async () => {
+        if (!existsSync(this.indexPath)) {
+          await this.saveIndex(this.emptyIndex());
+        }
       });
     }
     await this.reconcileIndex();
@@ -732,49 +750,51 @@ var FileStorage = class {
       skippedSchemaViolation: 0,
       skippedIoError: 0
     };
-    const index = await this.loadIndex();
-    const before = Object.keys(index.trajectories).length;
-    const discovered = [];
-    try {
-      const activeFiles = await readdir(this.activeDir);
-      for (const file of activeFiles) {
-        if (!file.endsWith(".json")) continue;
-        discovered.push(join(this.activeDir, file));
+    await withIndexLock(this.indexPath, async () => {
+      const index = await this.loadIndex();
+      const before = Object.keys(index.trajectories).length;
+      const discovered = [];
+      try {
+        const activeFiles = await readdir(this.activeDir);
+        for (const file of activeFiles) {
+          if (!file.endsWith(".json")) continue;
+          discovered.push(join(this.activeDir, file));
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
       }
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-    await this.walkJsonFilesInto(this.completedDir, discovered);
-    for (const filePath of discovered) {
-      summary.scanned += 1;
-      const result = await this.readTrajectoryFile(filePath);
-      if (!result.ok) {
-        if (result.reason === "malformed_json") {
-          summary.skippedMalformedJson += 1;
-        } else if (result.reason === "schema_violation") {
-          summary.skippedSchemaViolation += 1;
-        } else {
-          summary.skippedIoError += 1;
+      await this.walkJsonFilesInto(this.completedDir, discovered);
+      for (const filePath of discovered) {
+        summary.scanned += 1;
+        const result = await this.readTrajectoryFile(filePath);
+        if (!result.ok) {
+          if (result.reason === "malformed_json") {
+            summary.skippedMalformedJson += 1;
+          } else if (result.reason === "schema_violation") {
+            summary.skippedSchemaViolation += 1;
+          } else {
+            summary.skippedIoError += 1;
+          }
+          continue;
         }
-        continue;
+        const trajectory2 = result.trajectory;
+        if (index.trajectories[trajectory2.id]) {
+          summary.alreadyIndexed += 1;
+          continue;
+        }
+        index.trajectories[trajectory2.id] = {
+          title: trajectory2.task.title,
+          status: trajectory2.status,
+          startedAt: trajectory2.startedAt,
+          completedAt: trajectory2.completedAt,
+          path: filePath
+        };
+        summary.added += 1;
       }
-      const trajectory2 = result.trajectory;
-      if (index.trajectories[trajectory2.id]) {
-        summary.alreadyIndexed += 1;
-        continue;
+      if (Object.keys(index.trajectories).length !== before) {
+        await this.saveIndex(index);
       }
-      index.trajectories[trajectory2.id] = {
-        title: trajectory2.task.title,
-        status: trajectory2.status,
-        startedAt: trajectory2.startedAt,
-        completedAt: trajectory2.completedAt,
-        path: filePath
-      };
-      summary.added += 1;
-    }
-    if (Object.keys(index.trajectories).length !== before) {
-      await this.saveIndex(index);
-    }
+    });
     const hadSkips = summary.skippedMalformedJson + summary.skippedSchemaViolation + summary.skippedIoError > 0;
     if (summary.added > 0 || hadSkips) {
       const parts = [`reconciled ${summary.added}/${summary.scanned}`];
@@ -977,17 +997,19 @@ var FileStorage = class {
     if (existsSync(activePath)) {
       await unlink(activePath);
     }
-    const index = await this.loadIndex();
-    const entry = index.trajectories[id];
-    if (entry?.path && existsSync(entry.path)) {
-      await unlink(entry.path);
-      const mdPath = entry.path.replace(".json", ".md");
-      if (existsSync(mdPath)) {
-        await unlink(mdPath);
+    await withIndexLock(this.indexPath, async () => {
+      const index = await this.loadIndex();
+      const entry = index.trajectories[id];
+      if (entry?.path && existsSync(entry.path)) {
+        await unlink(entry.path);
+        const mdPath = entry.path.replace(".json", ".md");
+        if (existsSync(mdPath)) {
+          await unlink(mdPath);
+        }
       }
-    }
-    delete index.trajectories[id];
-    await this.saveIndex(index);
+      delete index.trajectories[id];
+      await this.saveIndex(index);
+    });
   }
   /**
    * Search trajectories by text
@@ -1065,10 +1087,23 @@ var FileStorage = class {
     const result = await this.readTrajectoryFile(path);
     return result.ok ? result.trajectory : null;
   }
+  /**
+   * Read and parse the on-disk index.
+   *
+   * Tolerances (belt-and-braces against the read/write race):
+   *   - ENOENT: first-run, return an empty index silently.
+   *   - Empty file: a concurrent writer truncated index.json in "w" mode
+   *     right before we read. Return an empty index silently — this is
+   *     not a real corruption, just an interleaving the mutex + atomic
+   *     rename should already prevent. Logging here would be noise.
+   *   - Non-empty but malformed JSON: genuinely corrupted on disk (hand
+   *     edit, disk error, etc). Log it and return an empty index so the
+   *     caller can recover, but keep the log so the problem is visible.
+   */
   async loadIndex() {
+    let content;
     try {
-      const content = await readFile(this.indexPath, "utf-8");
-      return JSON.parse(content);
+      content = await readFile(this.indexPath, "utf-8");
     } catch (error) {
       if (error.code !== "ENOENT") {
         console.error(
@@ -1076,27 +1111,56 @@ var FileStorage = class {
           error
         );
       }
-      return {
-        version: 1,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-        trajectories: {}
-      };
+      return this.emptyIndex();
+    }
+    if (content.length === 0) {
+      return this.emptyIndex();
+    }
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      console.error(
+        "Error loading trajectory index, using empty index:",
+        error
+      );
+      return this.emptyIndex();
     }
   }
+  emptyIndex() {
+    return {
+      version: 1,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      trajectories: {}
+    };
+  }
+  /**
+   * Atomic write: stage into a process-unique temp path in the same directory
+   * and then rename over the live file. `rename` is atomic on POSIX, so
+   * concurrent readers in any process either see the old complete file or
+   * the new complete file — never a half-written / zero-byte state.
+   *
+   * Callers MUST hold `withIndexLock(this.indexPath, ...)` so the in-process
+   * read-modify-write cycle stays serialized; the unique temp name also keeps
+   * parallel writers in other processes from colliding on a shared tmp path.
+   */
   async saveIndex(index) {
     index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile(this.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    const tmpPath = `${this.indexPath}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
+    await rename(tmpPath, this.indexPath);
   }
   async updateIndex(trajectory2, filePath) {
-    const index = await this.loadIndex();
-    index.trajectories[trajectory2.id] = {
-      title: trajectory2.task.title,
-      status: trajectory2.status,
-      startedAt: trajectory2.startedAt,
-      completedAt: trajectory2.completedAt,
-      path: filePath
-    };
-    await this.saveIndex(index);
+    await withIndexLock(this.indexPath, async () => {
+      const index = await this.loadIndex();
+      index.trajectories[trajectory2.id] = {
+        title: trajectory2.task.title,
+        status: trajectory2.status,
+        startedAt: trajectory2.startedAt,
+        completedAt: trajectory2.completedAt,
+        path: filePath
+      };
+      await this.saveIndex(index);
+    });
   }
 };
 
@@ -2039,4 +2103,4 @@ export {
   getCommitsBetween,
   getFilesChangedBetween
 };
-//# sourceMappingURL=chunk-2XT3DOJC.js.map
+//# sourceMappingURL=chunk-27AQPWHK.js.map