@elizaos/server 1.4.3-alpha.0 → 1.4.3-alpha.2

package/dist/index.js

@@ -21,7 +21,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // ../../node_modules/path-to-regexp/dist/index.js
 var require_dist = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  exports.TokenData = undefined;
+  exports.PathError = exports.TokenData = undefined;
   exports.parse = parse;
   exports.compile = compile;
   exports.match = match;
@@ -31,7 +31,6 @@ var require_dist = __commonJS((exports) => {
   var NOOP_VALUE = (value) => value;
   var ID_START = /^[$_\p{ID_Start}]$/u;
   var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-  var DEBUG_URL = "https://git.new/pathToRegexpError";
   var SIMPLE_TOKENS = {
     "{": "{",
     "}": "}",
@@ -44,151 +43,125 @@ var require_dist = __commonJS((exports) => {
     "!": "!"
   };
   function escapeText(str) {
-    return str.replace(/[{}()\[\]+?!:*]/g, "\\$&");
+    return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
   }
   function escape(str) {
     return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
   }
-  function* lexer(str) {
+
+  class TokenData {
+    constructor(tokens, originalPath) {
+      this.tokens = tokens;
+      this.originalPath = originalPath;
+    }
+  }
+  exports.TokenData = TokenData;
+
+  class PathError extends TypeError {
+    constructor(message, originalPath) {
+      let text = message;
+      if (originalPath)
+        text += `: ${originalPath}`;
+      text += `; visit https://git.new/pathToRegexpError for info`;
+      super(text);
+      this.originalPath = originalPath;
+    }
+  }
+  exports.PathError = PathError;
+  function parse(str, options = {}) {
+    const { encodePath = NOOP_VALUE } = options;
     const chars = [...str];
-    let i = 0;
+    const tokens = [];
+    let index = 0;
+    let pos = 0;
     function name() {
       let value = "";
-      if (ID_START.test(chars[++i])) {
-        value += chars[i];
-        while (ID_CONTINUE.test(chars[++i])) {
-          value += chars[i];
-        }
-      } else if (chars[i] === '"') {
-        let pos = i;
-        while (i < chars.length) {
-          if (chars[++i] === '"') {
-            i++;
-            pos = 0;
+      if (ID_START.test(chars[index])) {
+        do {
+          value += chars[index++];
+        } while (ID_CONTINUE.test(chars[index]));
+      } else if (chars[index] === '"') {
+        let quoteStart = index;
+        while (index++ < chars.length) {
+          if (chars[index] === '"') {
+            index++;
+            quoteStart = 0;
             break;
           }
-          if (chars[i] === "\\") {
-            value += chars[++i];
-          } else {
-            value += chars[i];
-          }
+          if (chars[index] === "\\")
+            index++;
+          value += chars[index];
         }
-        if (pos) {
-          throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);
+        if (quoteStart) {
+          throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
         }
       }
       if (!value) {
-        throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
+        throw new PathError(`Missing parameter name at index ${index}`, str);
       }
       return value;
     }
-    while (i < chars.length) {
-      const value = chars[i];
+    while (index < chars.length) {
+      const value = chars[index];
       const type = SIMPLE_TOKENS[value];
       if (type) {
-        yield { type, index: i++, value };
+        tokens.push({ type, index: index++, value });
       } else if (value === "\\") {
-        yield { type: "ESCAPED", index: i++, value: chars[i++] };
+        tokens.push({ type: "escape", index: index++, value: chars[index++] });
       } else if (value === ":") {
-        const value2 = name();
-        yield { type: "PARAM", index: i, value: value2 };
+        tokens.push({ type: "param", index: index++, value: name() });
       } else if (value === "*") {
-        const value2 = name();
-        yield { type: "WILDCARD", index: i, value: value2 };
+        tokens.push({ type: "wildcard", index: index++, value: name() });
       } else {
-        yield { type: "CHAR", index: i, value: chars[i++] };
+        tokens.push({ type: "char", index: index++, value });
       }
     }
-    return { type: "END", index: i, value: "" };
-  }
-
-  class Iter {
-    constructor(tokens) {
-      this.tokens = tokens;
-    }
-    peek() {
-      if (!this._peek) {
-        const next = this.tokens.next();
-        this._peek = next.value;
-      }
-      return this._peek;
-    }
-    tryConsume(type) {
-      const token = this.peek();
-      if (token.type !== type)
-        return;
-      this._peek = undefined;
-      return token.value;
-    }
-    consume(type) {
-      const value = this.tryConsume(type);
-      if (value !== undefined)
-        return value;
-      const { type: nextType, index } = this.peek();
-      throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);
-    }
-    text() {
-      let result = "";
-      let value;
-      while (value = this.tryConsume("CHAR") || this.tryConsume("ESCAPED")) {
-        result += value;
-      }
-      return result;
-    }
-  }
-
-  class TokenData {
-    constructor(tokens) {
-      this.tokens = tokens;
-    }
-  }
-  exports.TokenData = TokenData;
-  function parse(str, options = {}) {
-    const { encodePath = NOOP_VALUE } = options;
-    const it = new Iter(lexer(str));
-    function consume(endType) {
-      const tokens2 = [];
+    tokens.push({ type: "end", index, value: "" });
+    function consumeUntil(endType) {
+      const output = [];
       while (true) {
-        const path = it.text();
-        if (path)
-          tokens2.push({ type: "text", value: encodePath(path) });
-        const param = it.tryConsume("PARAM");
-        if (param) {
-          tokens2.push({
-            type: "param",
-            name: param
+        const token = tokens[pos++];
+        if (token.type === endType)
+          break;
+        if (token.type === "char" || token.type === "escape") {
+          let path = token.value;
+          let cur = tokens[pos];
+          while (cur.type === "char" || cur.type === "escape") {
+            path += cur.value;
+            cur = tokens[++pos];
+          }
+          output.push({
+            type: "text",
+            value: encodePath(path)
           });
           continue;
         }
-        const wildcard = it.tryConsume("WILDCARD");
-        if (wildcard) {
-          tokens2.push({
-            type: "wildcard",
-            name: wildcard
+        if (token.type === "param" || token.type === "wildcard") {
+          output.push({
+            type: token.type,
+            name: token.value
           });
           continue;
         }
-        const open = it.tryConsume("{");
-        if (open) {
-          tokens2.push({
+        if (token.type === "{") {
+          output.push({
             type: "group",
-            tokens: consume("}")
+            tokens: consumeUntil("}")
           });
           continue;
         }
-        it.consume(endType);
-        return tokens2;
+        throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
       }
+      return output;
     }
-    const tokens = consume("END");
-    return new TokenData(tokens);
+    return new TokenData(consumeUntil("end"), str);
   }
   function compile(path, options = {}) {
     const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
-    const data = path instanceof TokenData ? path : parse(path, options);
+    const data = typeof path === "object" ? path : parse(path, options);
     const fn = tokensToFunction(data.tokens, delimiter, encode);
-    return function path(data2 = {}) {
-      const [path2, ...missing] = fn(data2);
+    return function path(params = {}) {
+      const [path2, ...missing] = fn(params);
       if (missing.length) {
         throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
       }
@@ -277,14 +250,12 @@ var require_dist = __commonJS((exports) => {
   function pathToRegexp(path, options = {}) {
     const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
     const keys = [];
-    const sources = [];
     const flags = sensitive ? "" : "i";
-    const paths = Array.isArray(path) ? path : [path];
-    const items = paths.map((path2) => path2 instanceof TokenData ? path2 : parse(path2, options));
-    for (const { tokens } of items) {
-      for (const seq of flatten(tokens, 0, [])) {
-        const regexp2 = sequenceToRegExp(seq, delimiter, keys);
-        sources.push(regexp2);
+    const sources = [];
+    for (const input of pathsToArray(path, [])) {
+      const data = typeof input === "object" ? input : parse(input, options);
+      for (const tokens of flatten(data.tokens, 0, [])) {
+        sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
       }
     }
     let pattern = `^(?:${sources.join("|")})`;
@@ -294,14 +265,22 @@ var require_dist = __commonJS((exports) => {
     const regexp = new RegExp(pattern, flags);
     return { regexp, keys };
   }
+  function pathsToArray(paths, init) {
+    if (Array.isArray(paths)) {
+      for (const p of paths)
+        pathsToArray(p, init);
+    } else {
+      init.push(paths);
+    }
+    return init;
+  }
   function* flatten(tokens, index, init) {
     if (index === tokens.length) {
       return yield init;
     }
     const token = tokens[index];
     if (token.type === "group") {
-      const fork = init.slice();
-      for (const seq of flatten(token.tokens, 0, fork)) {
+      for (const seq of flatten(token.tokens, 0, init.slice())) {
         yield* flatten(tokens, index + 1, seq);
       }
     } else {
@@ -309,12 +288,11 @@ var require_dist = __commonJS((exports) => {
     }
     yield* flatten(tokens, index + 1, init);
   }
-  function sequenceToRegExp(tokens, delimiter, keys) {
+  function toRegExpSource(tokens, delimiter, keys, originalPath) {
     let result = "";
     let backtrack = "";
     let isSafeSegmentParam = true;
-    for (let i = 0;i < tokens.length; i++) {
-      const token = tokens[i];
+    for (const token of tokens) {
       if (token.type === "text") {
         result += escape(token.value);
         backtrack += token.value;
@@ -323,7 +301,7 @@ var require_dist = __commonJS((exports) => {
       }
       if (token.type === "param" || token.type === "wildcard") {
         if (!isSafeSegmentParam && !backtrack) {
-          throw new TypeError(`Missing text after "${token.name}": ${DEBUG_URL}`);
+          throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
         }
         if (token.type === "param") {
           result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
@@ -349,32 +327,46 @@ var require_dist = __commonJS((exports) => {
     }
     return `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\\s\\S])`;
   }
-  function stringify(data) {
-    return data.tokens.map(function stringifyToken(token, index, tokens) {
-      if (token.type === "text")
-        return escapeText(token.value);
+  function stringifyTokens(tokens) {
+    let value = "";
+    let i = 0;
+    function name(value2) {
+      const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
+      return isSafe ? value2 : JSON.stringify(value2);
+    }
+    while (i < tokens.length) {
+      const token = tokens[i++];
+      if (token.type === "text") {
+        value += escapeText(token.value);
+        continue;
+      }
       if (token.type === "group") {
-        return `{${token.tokens.map(stringifyToken).join("")}}`;
+        value += `{${stringifyTokens(token.tokens)}}`;
+        continue;
+      }
+      if (token.type === "param") {
+        value += `:${name(token.name)}`;
+        continue;
       }
-      const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);
-      const key = isSafe ? token.name : JSON.stringify(token.name);
-      if (token.type === "param")
-        return `:${key}`;
-      if (token.type === "wildcard")
-        return `*${key}`;
-      throw new TypeError(`Unexpected token: ${token}`);
-    }).join("");
+      if (token.type === "wildcard") {
+        value += `*${name(token.name)}`;
+        continue;
+      }
+      throw new TypeError(`Unknown token type: ${token.type}`);
+    }
+    return value;
+  }
+  function stringify(data) {
+    return stringifyTokens(data.tokens);
   }
   function isNameSafe(name) {
     const [first, ...rest] = name;
-    if (!ID_START.test(first))
-      return false;
-    return rest.every((char) => ID_CONTINUE.test(char));
+    return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
   }
   function isNextNameSafe(token) {
-    if ((token === null || token === undefined ? undefined : token.type) !== "text")
-      return true;
-    return !ID_CONTINUE.test(token.value[0]);
+    if (token && token.type === "text")
+      return !ID_CONTINUE.test(token.value[0]);
+    return true;
   }
 });
 
@@ -5834,7 +5826,7 @@ import express29 from "express";
 // package.json
 var package_default = {
   name: "@elizaos/server",
-  version: "1.4.2",
+  version: "1.4.3-alpha.1",
   description: "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   publishConfig: {
     access: "public",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/server",
-  "version": "1.4.3-alpha.0",
+  "version": "1.4.3-alpha.2",
   "description": "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   "publishConfig": {
     "access": "public",
@@ -51,10 +51,10 @@
     "which": "^4.0.0",
     "ws": "^8.18.0"
   },
-  "gitHead": "f2dd82949680a1e6fc61eb74683d2d95cf0173b6",
+  "gitHead": "fb236ff1b6b51541ea521489ac761e79fb51bf16",
   "dependencies": {
-    "@elizaos/core": "1.4.3-alpha.0",
-    "@elizaos/plugin-sql": "1.4.3-alpha.0",
+    "@elizaos/core": "1.4.3-alpha.2",
+    "@elizaos/plugin-sql": "1.4.3-alpha.2",
     "@types/express": "^5.0.2",
     "@types/helmet": "^4.0.0",
     "@types/multer": "^1.4.13",