@mastra/deployer 0.0.1-alpha.0

package/dist/deployer.esm.js

@@ -0,0 +1,2840 @@
+import * as fs from 'fs';
+import fs__default, { existsSync, mkdirSync, writeFileSync, readFileSync, copyFileSync } from 'fs';
+import path, { join, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { Workflow, Step } from '@mastra/core';
+import * as esbuild from 'esbuild';
+import { z } from 'zod';
+import fsExtra from 'fs-extra/esm';
+import { execSync } from 'child_process';
+import { execa } from 'execa';
+import fsPromises, { readFile } from 'fs/promises';
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { stringify } from 'superjson';
+import zodToJsonSchema from 'zod-to-json-schema';
+import { HTTPException } from 'hono/http-exception';
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+    t && (r = t);
+    var o = 0;
+    return function () {
+      return o >= r.length ? {
+        done: !0
+      } : {
+        done: !1,
+        value: r[o++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: !0
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+            return next.value = t, next.done = !0, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+          } else {
+            if (!u) throw Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+var EnvService = function EnvService() {};
+var FileEnvService = /*#__PURE__*/function (_EnvService) {
+  function FileEnvService(filePath) {
+    var _this;
+    _this = _EnvService.call(this) || this;
+    _this.filePath = void 0;
+    _this.filePath = filePath;
+    return _this;
+  }
+  _inheritsLoose(FileEnvService, _EnvService);
+  var _proto = FileEnvService.prototype;
+  _proto.readFile = function readFile(filePath) {
+    return new Promise(function (resolve, reject) {
+      fs.readFile(filePath, 'utf8', function (err, data) {
+        if (err) reject(err);else resolve(data);
+      });
+    });
+  };
+  _proto.writeFile = function writeFile(_ref) {
+    var filePath = _ref.filePath,
+      data = _ref.data;
+    return new Promise(function (resolve, reject) {
+      fs.writeFile(filePath, data, 'utf8', function (err) {
+        if (err) reject(err);else resolve();
+      });
+    });
+  };
+  _proto.updateEnvData = /*#__PURE__*/function () {
+    var _updateEnvData = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
+      var key, value, _ref2$filePath, filePath, data, regex;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            key = _ref2.key, value = _ref2.value, _ref2$filePath = _ref2.filePath, filePath = _ref2$filePath === void 0 ? this.filePath : _ref2$filePath, data = _ref2.data;
+            regex = new RegExp("^" + key + "=.*$", 'm');
+            if (data.match(regex)) {
+              data = data.replace(regex, key + "=" + value);
+            } else {
+              data += "\n" + key + "=" + value;
+            }
+            _context.next = 5;
+            return this.writeFile({
+              filePath: filePath,
+              data: data
+            });
+          case 5:
+            console.log(key + " set to " + value + " in ENV file.");
+            return _context.abrupt("return", data);
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function updateEnvData(_x) {
+      return _updateEnvData.apply(this, arguments);
+    }
+    return updateEnvData;
+  }();
+  _proto.getEnvValue = /*#__PURE__*/function () {
+    var _getEnvValue = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(key) {
+      var data, regex, match;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            _context2.next = 3;
+            return this.readFile(this.filePath);
+          case 3:
+            data = _context2.sent;
+            regex = new RegExp("^" + key + "=(.*)$", 'm');
+            match = data.match(regex);
+            return _context2.abrupt("return", (match == null ? void 0 : match[1]) || null);
+          case 9:
+            _context2.prev = 9;
+            _context2.t0 = _context2["catch"](0);
+            console.error("Error reading ENV value: " + _context2.t0);
+            return _context2.abrupt("return", null);
+          case 13:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this, [[0, 9]]);
+    }));
+    function getEnvValue(_x2) {
+      return _getEnvValue.apply(this, arguments);
+    }
+    return getEnvValue;
+  }();
+  _proto.setEnvValue = /*#__PURE__*/function () {
+    var _setEnvValue = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(key, value) {
+      var data;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            _context3.next = 3;
+            return this.readFile(this.filePath);
+          case 3:
+            data = _context3.sent;
+            _context3.next = 6;
+            return this.updateEnvData({
+              key: key,
+              value: value,
+              data: data
+            });
+          case 6:
+            _context3.next = 11;
+            break;
+          case 8:
+            _context3.prev = 8;
+            _context3.t0 = _context3["catch"](0);
+            console.error("Error writing ENV value: " + _context3.t0);
+          case 11:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this, [[0, 8]]);
+    }));
+    function setEnvValue(_x3, _x4) {
+      return _setEnvValue.apply(this, arguments);
+    }
+    return setEnvValue;
+  }();
+  return FileEnvService;
+}(EnvService);
+
+var FileService = /*#__PURE__*/function () {
+  function FileService() {}
+  var _proto = FileService.prototype;
+  /**
+   *
+   * @param inputFile the file in the starter files directory to copy
+   * @param outputFilePath the destination path
+   * @param replaceIfExists flag to replace if it exists
+   * @returns
+   */
+  _proto.copyStarterFile =
+  /*#__PURE__*/
+  function () {
+    var _copyStarterFile = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(inputFile, outputFilePath, replaceIfExists) {
+      var __filename, __dirname, filePath, fileString;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            __filename = fileURLToPath(import.meta.url);
+            __dirname = path.dirname(__filename);
+            filePath = path.resolve(__dirname, '..', 'starter-files', inputFile);
+            fileString = fs__default.readFileSync(filePath, 'utf8');
+            if (!(fs__default.existsSync(outputFilePath) && !replaceIfExists)) {
+              _context.next = 7;
+              break;
+            }
+            console.log(outputFilePath + " already exists");
+            return _context.abrupt("return", false);
+          case 7:
+            _context.next = 9;
+            return fsExtra.outputFile(outputFilePath, fileString);
+          case 9:
+            return _context.abrupt("return", true);
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function copyStarterFile(_x, _x2, _x3) {
+      return _copyStarterFile.apply(this, arguments);
+    }
+    return copyStarterFile;
+  }();
+  _proto.setupEnvFile = /*#__PURE__*/function () {
+    var _setupEnvFile = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref) {
+      var dbUrl, envPath, fileEnvService;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            dbUrl = _ref.dbUrl;
+            envPath = path.join(process.cwd(), '.env.development');
+            _context2.next = 4;
+            return fsExtra.ensureFile(envPath);
+          case 4:
+            fileEnvService = new FileEnvService(envPath);
+            _context2.next = 7;
+            return fileEnvService.setEnvValue('DB_URL', dbUrl);
+          case 7:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    function setupEnvFile(_x4) {
+      return _setupEnvFile.apply(this, arguments);
+    }
+    return setupEnvFile;
+  }();
+  _proto.getFirstExistingFile = function getFirstExistingFile(files) {
+    for (var _iterator = _createForOfIteratorHelperLoose(files), _step; !(_step = _iterator()).done;) {
+      var f = _step.value;
+      if (fs__default.existsSync(f)) {
+        return f;
+      }
+    }
+    throw new Error('Missing required file, checked the following paths: ' + files.join(', '));
+  };
+  _proto.replaceValuesInFile = function replaceValuesInFile(_ref2) {
+    var filePath = _ref2.filePath,
+      replacements = _ref2.replacements;
+    var fileContent = fs__default.readFileSync(filePath, 'utf8');
+    replacements.forEach(function (_ref3) {
+      var search = _ref3.search,
+        replace = _ref3.replace;
+      fileContent = fileContent.replaceAll(search, replace);
+    });
+    fs__default.writeFileSync(filePath, fileContent);
+  };
+  return FileService;
+}();
+
+function upsertMastraDir() {
+  var dirPath = join(process.cwd(), '.mastra');
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, {
+      recursive: true
+    });
+    execSync("echo \".mastra\" >> .gitignore");
+  }
+}
+
+var buildWorkflow = /*#__PURE__*/new Workflow({
+  name: 'Build',
+  triggerSchema: /*#__PURE__*/z.object({
+    buildName: /*#__PURE__*/z.string(),
+    entry: /*#__PURE__*/z.string(),
+    outfile: /*#__PURE__*/z.string().optional(),
+    useBanner: /*#__PURE__*/z["boolean"]().optional(),
+    devMode: /*#__PURE__*/z["boolean"]().optional()
+  })
+});
+buildWorkflow.__setLogger(null);
+var ensureDir = /*#__PURE__*/new Step({
+  id: 'Ensure Directory',
+  execute: (/*#__PURE__*/function () {
+    var _execute = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            // Ensure .mastra directory exists
+            upsertMastraDir();
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function execute() {
+      return _execute.apply(this, arguments);
+    }
+    return execute;
+  }())
+});
+var bundleStep = /*#__PURE__*/new Step({
+  id: 'Bundle',
+  execute: (/*#__PURE__*/function () {
+    var _execute2 = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref) {
+      var _context$machineConte, _context$machineConte2, _context$machineConte3, _context$machineConte4, _context$machineConte5;
+      var context, devMode, buildName, useBanner, entry, outfile, fileService, entryPoint, outfilePath, plugins, missingMastraDependency, externalIfMissingPlugin, esbuildConfig, result;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            context = _ref.context;
+            devMode = (_context$machineConte = context.machineContext) == null ? void 0 : _context$machineConte.triggerData.devMode;
+            buildName = (_context$machineConte2 = context.machineContext) == null ? void 0 : _context$machineConte2.triggerData.buildName;
+            useBanner = (_context$machineConte3 = context.machineContext) == null ? void 0 : _context$machineConte3.triggerData.useBanner;
+            entry = (_context$machineConte4 = context.machineContext) == null ? void 0 : _context$machineConte4.triggerData.entry;
+            outfile = (_context$machineConte5 = context.machineContext) == null ? void 0 : _context$machineConte5.triggerData.outfile;
+            fileService = new FileService();
+            entryPoint = fileService.getFirstExistingFile([entry]);
+            outfilePath = outfile || join(process.cwd(), '.mastra', 'mastra.mjs');
+            plugins = [];
+            missingMastraDependency = false;
+            externalIfMissingPlugin = {
+              name: 'external-if-missing',
+              setup: function setup(build) {
+                build.onResolve({
+                  filter: /^.*$/
+                },
+                // @ts-ignore
+                function (args) {
+                  if (!args.importer.endsWith('.mastra/index.mjs')) return;
+                  try {
+                    var resolvedPath = import.meta.resolve(args.path);
+                    if (!resolvedPath || resolvedPath.includes('_npx/')) {
+                      missingMastraDependency = true;
+                      return {
+                        path: args.path,
+                        external: true
+                      };
+                    }
+                  } catch (e) {
+                    missingMastraDependency = true;
+                    return {
+                      path: args.path,
+                      external: true
+                    };
+                  }
+                });
+              }
+            };
+            if (devMode) {
+              plugins.push(externalIfMissingPlugin);
+            }
+            esbuildConfig = {
+              entryPoints: [entryPoint],
+              bundle: true,
+              platform: 'node',
+              format: 'esm',
+              outfile: outfilePath,
+              target: 'node20',
+              sourcemap: true,
+              logLevel: 'silent',
+              minify: false,
+              metafile: true,
+              mainFields: ['module', 'main'],
+              conditions: ['import', 'node'],
+              logOverride: {
+                'commonjs-variable-in-esm': 'silent'
+              },
+              external: ['execa',
+              // Mark node built-ins as external
+              'assert', 'buffer', 'child_process', 'cluster', 'constants', 'crypto', 'dgram', 'dns', 'events', 'fs', 'http', 'http2', 'https', 'module', 'net', 'os', 'path', 'punycode', 'querystring', 'readline', 'repl', 'stream', 'string_decoder', 'sys', 'timers', 'tls', 'tty', 'url', 'util', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib', 'chromium-bidi/lib/cjs/bidiMapper/BidiMapper', 'chromium-bidi/lib/cjs/cdp/CdpConnection',
+              // Your packages
+              '@mastra/core', '@mastra/memory', '@mastra/engine', '@mastra/rag', '@mastra/evals', '@mastra/mcp', '@mastra/tts', '@mastra/firecrawl', '@mastra/github', '@mastra/stabilityai', '@mastra/deployer', '@mastra/deployer-cloudflare', '@mastra/deployer-netlify', '@mastra/deployer-vercel'],
+              plugins: plugins
+            };
+            if (useBanner) {
+              esbuildConfig.banner = {
+                js: "\n                import { createRequire } from \"node:module\";                \n                const require = createRequire(import.meta.url || 'file:///');\n              "
+              };
+            }
+            _context2.next = 17;
+            return esbuild.build(esbuildConfig);
+          case 17:
+            result = _context2.sent;
+            if (devMode && missingMastraDependency) {
+              console.error("Missing Mastra dependency. Please install the mastra package in your project or globally using npm i -g mastra");
+              process.exit(1);
+            }
+            // Log build results
+            console.log("[" + buildName + "]: build completed successfully");
+            return _context2.abrupt("return", result);
+          case 21:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    function execute(_x) {
+      return _execute2.apply(this, arguments);
+    }
+    return execute;
+  }())
+});
+var analyzeStep = /*#__PURE__*/new Step({
+  id: 'Analyze',
+  execute: (/*#__PURE__*/function () {
+    var _execute3 = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref2) {
+      var _context$machineConte6, _context$machineConte7, _context$machineConte8;
+      var context, res;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            context = _ref2.context;
+            if (!((context == null || (_context$machineConte6 = context.machineContext) == null || (_context$machineConte6 = _context$machineConte6.stepResults) == null || (_context$machineConte6 = _context$machineConte6.Bundle) == null ? void 0 : _context$machineConte6.status) !== 'success')) {
+              _context3.next = 3;
+              break;
+            }
+            throw new Error('Bundle step failed');
+          case 3:
+            writeFileSync(join(process.cwd(), '.mastra', 'metafile.json'), JSON.stringify((_context$machineConte7 = context.machineContext) == null ? void 0 : _context$machineConte7.stepResults.Bundle.payload.metafile, null, 2));
+            _context3.next = 6;
+            return esbuild.analyzeMetafile((_context$machineConte8 = context.machineContext) == null ? void 0 : _context$machineConte8.stepResults.Bundle.payload.metafile);
+          case 6:
+            res = _context3.sent;
+            return _context3.abrupt("return", res);
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    function execute(_x2) {
+      return _execute3.apply(this, arguments);
+    }
+    return execute;
+  }())
+});
+buildWorkflow.step(ensureDir).then(bundleStep).then(analyzeStep).commit();
+function bundle(_x3, _x4) {
+  return _bundle.apply(this, arguments);
+}
+function _bundle() {
+  _bundle = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(entry, _temp) {
+    var _ref3, _ref3$useBanner, useBanner, _ref3$buildName, buildName, outfile, devMode, _buildWorkflow$create, start;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _ref3 = _temp === void 0 ? {} : _temp, _ref3$useBanner = _ref3.useBanner, useBanner = _ref3$useBanner === void 0 ? true : _ref3$useBanner, _ref3$buildName = _ref3.buildName, buildName = _ref3$buildName === void 0 ? 'Build' : _ref3$buildName, outfile = _ref3.outfile, devMode = _ref3.devMode;
+          _buildWorkflow$create = buildWorkflow.createRun(), start = _buildWorkflow$create.start;
+          _context4.prev = 2;
+          _context4.next = 5;
+          return start({
+            triggerData: {
+              buildName: buildName,
+              entry: entry,
+              useBanner: useBanner,
+              outfile: outfile,
+              devMode: devMode
+            }
+          });
+        case 5:
+          _context4.next = 11;
+          break;
+        case 7:
+          _context4.prev = 7;
+          _context4.t0 = _context4["catch"](2);
+          console.error('Failed to build:', _context4.t0);
+          process.exit(1);
+        case 11:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[2, 7]]);
+  }));
+  return _bundle.apply(this, arguments);
+}
+
+var Deps = /*#__PURE__*/function () {
+  function Deps() {
+    this.packageManager = void 0;
+    this.packageManager = this.getPackageManager();
+  }
+  var _proto = Deps.prototype;
+  _proto.findLockFile = function findLockFile(dir) {
+    var lockFiles = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock'];
+    for (var _i = 0, _lockFiles = lockFiles; _i < _lockFiles.length; _i++) {
+      var file = _lockFiles[_i];
+      if (fs__default.existsSync(path.join(dir, file))) {
+        return file;
+      }
+    }
+    var parentDir = path.resolve(dir, '..');
+    if (parentDir !== dir) {
+      return this.findLockFile(parentDir);
+    }
+    return null;
+  };
+  _proto.getPackageManager = function getPackageManager() {
+    var lockFile = this.findLockFile(process.cwd());
+    switch (lockFile) {
+      case 'pnpm-lock.yaml':
+        return 'pnpm';
+      case 'package-lock.json':
+        return 'npm';
+      case 'yarn.lock':
+        return 'yarn';
+      default:
+        return 'npm';
+    }
+  };
+  _proto.install = /*#__PURE__*/function () {
+    var _install = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(packages) {
+      var runCommand, _packages;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (packages === void 0) {
+              packages = [];
+            }
+            runCommand = this.packageManager;
+            if (this.packageManager === 'npm') {
+              runCommand = this.packageManager + " i";
+            } else {
+              runCommand = this.packageManager + " " + (((_packages = packages) == null ? void 0 : _packages.length) > 0 ? "add" : "install");
+            }
+            return _context.abrupt("return", execa("" + runCommand, packages, {
+              all: true,
+              shell: true,
+              stdio: 'inherit'
+            }));
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function install(_x) {
+      return _install.apply(this, arguments);
+    }
+    return install;
+  }();
+  _proto.installPackages = /*#__PURE__*/function () {
+    var _installPackages = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(packages) {
+      var runCommand, packageList;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            runCommand = this.packageManager;
+            if (this.packageManager === 'npm') {
+              runCommand = this.packageManager + " i";
+            } else {
+              runCommand = this.packageManager + " add";
+            }
+            packageList = packages.join(' ');
+            return _context2.abrupt("return", execa(runCommand + " " + packageList, {
+              all: true,
+              shell: true,
+              stdio: 'inherit'
+            }));
+          case 4:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function installPackages(_x2) {
+      return _installPackages.apply(this, arguments);
+    }
+    return installPackages;
+  }();
+  _proto.checkDependencies = /*#__PURE__*/function () {
+    var _checkDependencies = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(dependencies) {
+      var packageJsonPath, packageJson, _iterator, _step, dependency;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            packageJsonPath = path.join(process.cwd(), 'package.json');
+            _context3.prev = 2;
+            _context3.next = 5;
+            return fsPromises.access(packageJsonPath);
+          case 5:
+            _context3.next = 10;
+            break;
+          case 7:
+            _context3.prev = 7;
+            _context3.t0 = _context3["catch"](2);
+            return _context3.abrupt("return", 'No package.json file found in the current directory');
+          case 10:
+            _context3.t1 = JSON;
+            _context3.next = 13;
+            return fsPromises.readFile(packageJsonPath, 'utf-8');
+          case 13:
+            _context3.t2 = _context3.sent;
+            packageJson = _context3.t1.parse.call(_context3.t1, _context3.t2);
+            _iterator = _createForOfIteratorHelperLoose(dependencies);
+          case 16:
+            if ((_step = _iterator()).done) {
+              _context3.next = 22;
+              break;
+            }
+            dependency = _step.value;
+            if (!(!packageJson.dependencies || !packageJson.dependencies[dependency])) {
+              _context3.next = 20;
+              break;
+            }
+            return _context3.abrupt("return", "Please install " + dependency + " before running this command (" + this.packageManager + " install " + dependency + ")");
+          case 20:
+            _context3.next = 16;
+            break;
+          case 22:
+            return _context3.abrupt("return", 'ok');
+          case 25:
+            _context3.prev = 25;
+            _context3.t3 = _context3["catch"](0);
+            console.error(_context3.t3);
+            return _context3.abrupt("return", 'Could not check dependencies');
+          case 29:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this, [[0, 25], [2, 7]]);
+    }));
+    function checkDependencies(_x3) {
+      return _checkDependencies.apply(this, arguments);
+    }
+    return checkDependencies;
+  }();
+  _proto.getProjectName = /*#__PURE__*/function () {
+    var _getProjectName = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+      var packageJsonPath, packageJson, pkg;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.prev = 0;
+            packageJsonPath = path.join(process.cwd(), 'package.json');
+            _context4.next = 4;
+            return fsPromises.readFile(packageJsonPath, 'utf-8');
+          case 4:
+            packageJson = _context4.sent;
+            pkg = JSON.parse(packageJson);
+            return _context4.abrupt("return", pkg.name);
+          case 9:
+            _context4.prev = 9;
+            _context4.t0 = _context4["catch"](0);
+            throw _context4.t0;
+          case 12:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, null, [[0, 9]]);
+    }));
+    function getProjectName() {
+      return _getProjectName.apply(this, arguments);
+    }
+    return getProjectName;
+  }();
+  _proto.getPackageVersion = /*#__PURE__*/function () {
+    var _getPackageVersion = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+      var __filename, __dirname, pkgJsonPath, content;
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            __filename = fileURLToPath(import.meta.url);
+            __dirname = dirname(__filename);
+            pkgJsonPath = path.join(__dirname, '..', '..', 'package.json');
+            _context5.next = 5;
+            return fsExtra.readJSON(pkgJsonPath);
+          case 5:
+            content = _context5.sent;
+            return _context5.abrupt("return", content.version);
+          case 7:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    }));
+    function getPackageVersion() {
+      return _getPackageVersion.apply(this, arguments);
+    }
+    return getPackageVersion;
+  }();
+  _proto.addScriptsToPackageJson = /*#__PURE__*/function () {
+    var _addScriptsToPackageJson = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(scripts) {
+      var packageJson;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.t0 = JSON;
+            _context6.next = 3;
+            return fsPromises.readFile('package.json', 'utf-8');
+          case 3:
+            _context6.t1 = _context6.sent;
+            packageJson = _context6.t0.parse.call(_context6.t0, _context6.t1);
+            packageJson.scripts = _extends({}, packageJson.scripts, scripts);
+            _context6.next = 8;
+            return fsPromises.writeFile('package.json', JSON.stringify(packageJson, null, 2));
+          case 8:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    }));
+    function addScriptsToPackageJson(_x4) {
+      return _addScriptsToPackageJson.apply(this, arguments);
+    }
+    return addScriptsToPackageJson;
+  }();
+  return Deps;
+}();
+
+var Deployer = /*#__PURE__*/function () {
+  function Deployer(_ref) {
+    var _this = this;
+    var dir = _ref.dir,
+      type = _ref.type;
+    this.deps = new Deps();
+    this.dotMastraPath = void 0;
+    this.name = '';
+    this.type = void 0;
+    this.log = function (message) {
+      console.log("[Mastra " + _this.type + "] - " + message);
+    };
+    this.dotMastraPath = join(dir, '.mastra');
+    this.type = type;
+  }
+  var _proto = Deployer.prototype;
+  _proto.getMastraPath = function getMastraPath() {
+    return this.dotMastraPath;
+  };
+  _proto.getMastra = /*#__PURE__*/function () {
+    var _getMastra = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return import(join(this.dotMastraPath, 'mastra.mjs'));
+          case 2:
+            return _context.abrupt("return", _context.sent);
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function getMastra() {
+      return _getMastra.apply(this, arguments);
+    }
+    return getMastra;
+  }();
+  _proto.writePackageJson = /*#__PURE__*/function () {
+    var _writePackageJson = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var projectPkg, mastraDeps, pkgPath;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            this.log('Writing package.json');
+            projectPkg = {
+              dependencies: {}
+            };
+            try {
+              projectPkg = JSON.parse(readFileSync(join(this.dotMastraPath, '..', 'package.json'), 'utf-8'));
+            } catch (_e) {
+              // no-op
+            }
+            mastraDeps = Object.entries(projectPkg.dependencies).filter(function (_ref2) {
+              var name = _ref2[0];
+              return name.startsWith('@mastra') && !name.startsWith('@mastra/deployer');
+            }).reduce(function (acc, _ref3) {
+              var name = _ref3[0],
+                version = _ref3[1];
+              if (version === 'workspace:*') {
+                acc[name] = 'latest';
+              } else {
+                acc[name] = version;
+              }
+              return acc;
+            }, {});
+            pkgPath = join(this.dotMastraPath, 'package.json');
+            if (!(this.type === 'Dev' && existsSync(pkgPath))) {
+              _context2.next = 7;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 7:
+            writeFileSync(pkgPath, JSON.stringify({
+              name: 'server',
+              version: '1.0.0',
+              description: '',
+              type: 'module',
+              main: 'index.mjs',
+              scripts: {
+                start: 'node ./index.mjs'
+              },
+              author: '',
+              license: 'ISC',
+              dependencies: _extends({}, mastraDeps, {
+                hono: '4.6.17',
+                execa: 'latest',
+                '@hono/node-server': '^1.13.7',
+                superjson: '^2.2.2',
+                'zod-to-json-schema': '^3.24.1'
+              })
+            }, null, 2));
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function writePackageJson() {
+      return _writePackageJson.apply(this, arguments);
+    }
+    return writePackageJson;
+  }();
+  _proto.install = /*#__PURE__*/function () {
+    var _install = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            this.log('Ensuring your dependencies up to date...');
+            _context3.next = 3;
+            return this.deps.install();
+          case 3:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this);
+    }));
+    function install() {
+      return _install.apply(this, arguments);
+    }
+    return install;
+  }();
+  _proto.getEnvFiles = function getEnvFiles() {
+    var envFiles = ['.env', '.env.development', '.env.local'].map(function (file) {
+      return join(process.cwd(), file);
+    }).filter(function (file) {
+      return existsSync(file);
+    });
+    return envFiles;
+  };
+  _proto.getEnvVars = function getEnvVars() {
+    // Get all env vars
+    var envFiles = this.getEnvFiles();
+    var envVars = {};
+    for (var _iterator = _createForOfIteratorHelperLoose(envFiles), _step; !(_step = _iterator()).done;) {
+      var file = _step.value;
+      var vars = this.parseEnvFile(file);
+      for (var _iterator2 = _createForOfIteratorHelperLoose(vars), _step2; !(_step2 = _iterator2()).done;) {
+        var envVar = _step2.value;
+        var _envVar$split = envVar.split('='),
+          key = _envVar$split[0],
+          value = _envVar$split[1];
+        if (key && value) {
+          envVars[key] = value;
+        }
+      }
+    }
+    return envVars;
+  };
+  _proto.parseEnvFile = function parseEnvFile(filePath) {
+    var content = readFileSync(filePath, 'utf-8');
+    return content.split('\n').map(function (line) {
+      return line.trim();
+    }).filter(function (line) {
+      return line && !line.startsWith('#');
+    }).filter(function (line) {
+      return line.includes('=');
+    }); // Only include valid KEY=value pairs
+  };
+  _proto.build = /*#__PURE__*/function () {
+    var _build = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref4) {
+      var dir, _ref4$useBanner, useBanner;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            dir = _ref4.dir, _ref4$useBanner = _ref4.useBanner, useBanner = _ref4$useBanner === void 0 ? true : _ref4$useBanner;
+            if (!existsSync(this.dotMastraPath)) {
+              mkdirSync(this.dotMastraPath);
+            }
+            _context4.next = 4;
+            return bundle(dir, {
+              useBanner: useBanner,
+              outfile: join(this.dotMastraPath, 'mastra.mjs')
+            });
+          case 4:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this);
+    }));
+    function build(_x) {
+      return _build.apply(this, arguments);
+    }
+    return build;
+  }();
+  _proto.buildServer = /*#__PURE__*/function () {
+    var _buildServer = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(_temp) {
+      var _ref5, _ref5$playground, playground, templatePath;
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            _ref5 = _temp === void 0 ? {
+              playground: false
+            } : _temp, _ref5$playground = _ref5.playground, playground = _ref5$playground === void 0 ? false : _ref5$playground;
+            upsertMastraDir();
+            templatePath = join(this.dotMastraPath, 'hono.mjs');
+            writeFileSync(templatePath, "\n      import { createHonoServer } from './server.mjs';\n      import { mastra } from './mastra.mjs';\n\n      export const app = await createHonoServer(mastra, { playground: " + playground + " });\n    ");
+          case 4:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this);
+    }));
+    function buildServer(_x2) {
+      return _buildServer.apply(this, arguments);
+    }
+    return buildServer;
+  }();
+  _proto.writeServerFile = /*#__PURE__*/function () {
+    var _writeServerFile = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+      var fileServerPath, serverPath;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 2;
+            return import.meta.resolve('@mastra/deployer/server');
+          case 2:
+            fileServerPath = _context6.sent;
+            serverPath = fileURLToPath(fileServerPath);
+            copyFileSync(serverPath, join(this.dotMastraPath, 'server.mjs'));
+          case 5:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6, this);
+    }));
+    function writeServerFile() {
+      return _writeServerFile.apply(this, arguments);
+    }
+    return writeServerFile;
+  }();
+  _proto.prepare = /*#__PURE__*/function () {
+    var _prepare = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(_ref6) {
+      var dir, playground, _ref6$useBanner, useBanner, dirPath;
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            dir = _ref6.dir, playground = _ref6.playground, _ref6$useBanner = _ref6.useBanner, useBanner = _ref6$useBanner === void 0 ? true : _ref6$useBanner;
+            this.log('Preparing .mastra directory');
+            upsertMastraDir();
+            dirPath = dir || path.join(process.cwd(), 'src/mastra');
+            this.writePackageJson();
+            this.writeServerFile();
+            _context7.next = 8;
+            return this.install();
+          case 8:
+            _context7.next = 10;
+            return this.build({
+              dir: dirPath,
+              useBanner: useBanner
+            });
+          case 10:
+            _context7.next = 12;
+            return this.buildServer({
+              playground: playground
+            });
+          case 12:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7, this);
+    }));
+    function prepare(_x3) {
+      return _prepare.apply(this, arguments);
+    }
+    return prepare;
+  }();
+  return Deployer;
+}();
+
+// Helper to handle errors consistently
+function handleError(error, defaultMessage) {
+  console.error(defaultMessage, error);
+  var apiError = error;
+  throw new HTTPException(apiError.status || 500, {
+    message: apiError.message || defaultMessage
+  });
+}
+
+// Validation helper
+function validateBody(body) {
+  var errorResponse = Object.entries(body).reduce(function (acc, _ref) {
+    var key = _ref[0],
+      value = _ref[1];
+    if (!value) {
+      acc[key] = key + " is required";
+    }
+    return acc;
+  }, {});
+  if (Object.keys(errorResponse).length > 0) {
+    throw new HTTPException(400, {
+      message: JSON.stringify(errorResponse)
+    });
+  }
+}
+
+// Agent handlers
+function getAgentsHandler(_x) {
+  return _getAgentsHandler.apply(this, arguments);
+}
+function _getAgentsHandler() {
+  _getAgentsHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(c) {
+    var mastra, agents, serializedAgents;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          mastra = c.get('mastra');
+          agents = mastra.getAgents();
+          serializedAgents = Object.entries(agents).reduce(function (acc, _ref) {
+            var _id = _ref[0],
+              _agent = _ref[1];
+            var agent = _agent;
+            var serializedAgentTools = Object.entries((agent == null ? void 0 : agent.tools) || {}).reduce(function (acc, _ref2) {
+              var key = _ref2[0],
+                tool = _ref2[1];
+              var _tool = tool;
+              acc[key] = _extends({}, _tool, {
+                inputSchema: _tool.inputSchema ? stringify(zodToJsonSchema(_tool.inputSchema)) : undefined,
+                outputSchema: _tool.outputSchema ? stringify(zodToJsonSchema(_tool.outputSchema)) : undefined
+              });
+              return acc;
+            }, {});
+            acc[_id] = _extends({}, agent, {
+              tools: serializedAgentTools
+            });
+            return acc;
+          }, {});
+          return _context.abrupt("return", c.json(serializedAgents));
+        case 7:
+          _context.prev = 7;
+          _context.t0 = _context["catch"](0);
+          return _context.abrupt("return", handleError(_context.t0, 'Error getting agents'));
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 7]]);
+  }));
+  return _getAgentsHandler.apply(this, arguments);
+}
+function getAgentByIdHandler(_x2) {
+  return _getAgentByIdHandler.apply(this, arguments);
+}
+function _getAgentByIdHandler() {
+  _getAgentByIdHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(c) {
+    var mastra, agentId, agent, serializedAgentTools;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.prev = 0;
+          mastra = c.get('mastra');
+          agentId = c.req.param('agentId');
+          agent = mastra.getAgent(agentId);
+          if (agent) {
+            _context2.next = 6;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Agent not found'
+          });
+        case 6:
+          serializedAgentTools = Object.entries((agent == null ? void 0 : agent.tools) || {}).reduce(function (acc, _ref3) {
+            var key = _ref3[0],
+              tool = _ref3[1];
+            var _tool = tool;
+            acc[key] = _extends({}, _tool, {
+              inputSchema: _tool.inputSchema ? stringify(zodToJsonSchema(_tool.inputSchema)) : undefined,
+              outputSchema: _tool.outputSchema ? stringify(zodToJsonSchema(_tool.outputSchema)) : undefined
+            });
+            return acc;
+          }, {});
+          return _context2.abrupt("return", c.json(_extends({}, agent, {
+            tools: serializedAgentTools
+          })));
+        case 10:
+          _context2.prev = 10;
+          _context2.t0 = _context2["catch"](0);
+          return _context2.abrupt("return", handleError(_context2.t0, 'Error getting agent'));
+        case 13:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[0, 10]]);
+  }));
+  return _getAgentByIdHandler.apply(this, arguments);
+}
+function generateHandler(_x3) {
+  return _generateHandler.apply(this, arguments);
+}
+function _generateHandler() {
+  _generateHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(c) {
+    var mastra, agentId, agent, _yield$c$req$json, messages, threadId, resourceid, output, result;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.prev = 0;
+          mastra = c.get('mastra');
+          agentId = c.req.param('agentId');
+          agent = mastra.getAgent(agentId);
+          if (agent) {
+            _context3.next = 6;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Agent not found'
+          });
+        case 6:
+          _context3.next = 8;
+          return c.req.json();
+        case 8:
+          _yield$c$req$json = _context3.sent;
+          messages = _yield$c$req$json.messages;
+          threadId = _yield$c$req$json.threadId;
+          resourceid = _yield$c$req$json.resourceid;
+          output = _yield$c$req$json.output;
+          validateBody({
+            messages: messages
+          });
+          if (Array.isArray(messages)) {
+            _context3.next = 16;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Messages should be an array'
+          });
+        case 16:
+          _context3.next = 18;
+          return agent.generate(messages, {
+            threadId: threadId,
+            resourceid: resourceid,
+            output: output
+          });
+        case 18:
+          result = _context3.sent;
+          return _context3.abrupt("return", c.json(result));
+        case 22:
+          _context3.prev = 22;
+          _context3.t0 = _context3["catch"](0);
+          return _context3.abrupt("return", handleError(_context3.t0, 'Error generating from agent'));
+        case 25:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[0, 22]]);
+  }));
+  return _generateHandler.apply(this, arguments);
+}
+function streamGenerateHandler(_x4) {
+  return _streamGenerateHandler.apply(this, arguments);
+}
+function _streamGenerateHandler() {
+  _streamGenerateHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(c) {
+    var mastra, agentId, agent, _yield$c$req$json2, messages, threadId, resourceid, output, streamResult;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.prev = 0;
+          mastra = c.get('mastra');
+          agentId = c.req.param('agentId');
+          agent = mastra.getAgent(agentId);
+          if (agent) {
+            _context4.next = 6;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Agent not found'
+          });
+        case 6:
+          _context4.next = 8;
+          return c.req.json();
+        case 8:
+          _yield$c$req$json2 = _context4.sent;
+          messages = _yield$c$req$json2.messages;
+          threadId = _yield$c$req$json2.threadId;
+          resourceid = _yield$c$req$json2.resourceid;
+          output = _yield$c$req$json2.output;
+          validateBody({
+            messages: messages
+          });
+          if (Array.isArray(messages)) {
+            _context4.next = 16;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Messages should be an array'
+          });
+        case 16:
+          _context4.next = 18;
+          return agent.stream(messages, {
+            threadId: threadId,
+            resourceid: resourceid,
+            output: output
+          });
+        case 18:
+          streamResult = _context4.sent;
+          return _context4.abrupt("return", new Response(streamResult.toDataStream(), {
+            headers: {
+              'Content-Type': 'text/x-unknown',
+              'content-encoding': 'identity',
+              'transfer-encoding': 'chunked'
+            }
+          }));
+        case 22:
+          _context4.prev = 22;
+          _context4.t0 = _context4["catch"](0);
+          return _context4.abrupt("return", handleError(_context4.t0, 'Error streaming from agent'));
+        case 25:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[0, 22]]);
+  }));
+  return _streamGenerateHandler.apply(this, arguments);
+}
+
+var clients = /*#__PURE__*/new Set();
+function handleClientsRefresh(c) {
+  var stream = new ReadableStream({
+    start: function start(controller) {
+      clients.add(controller);
+      controller.enqueue('data: connected\n\n');
+      c.req.raw.signal.addEventListener('abort', function () {
+        clients["delete"](controller);
+      });
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+      'Access-Control-Allow-Origin': '*'
+    }
+  });
+}
+function handleTriggerClientsRefresh(c) {
+  clients.forEach(function (controller) {
+    try {
+      controller.enqueue('data: refresh\n\n');
+    } catch (_unused) {
+      clients["delete"](controller);
+    }
+  });
+  return c.json({
+    success: true,
+    clients: clients.size
+  });
+}
+
+function getLogsHandler(_x) {
+  return _getLogsHandler.apply(this, arguments);
+}
+function _getLogsHandler() {
+  _getLogsHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(c) {
+    var mastra, logs;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          mastra = c.get('mastra');
+          _context.next = 4;
+          return mastra.getLogs();
+        case 4:
+          logs = _context.sent;
+          return _context.abrupt("return", c.json(logs));
+        case 8:
+          _context.prev = 8;
+          _context.t0 = _context["catch"](0);
+          return _context.abrupt("return", handleError(_context.t0, 'Error getting logs'));
+        case 11:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 8]]);
+  }));
+  return _getLogsHandler.apply(this, arguments);
+}
+function getLogsByRunIdHandler(_x2) {
+  return _getLogsByRunIdHandler.apply(this, arguments);
+}
+function _getLogsByRunIdHandler() {
+  _getLogsByRunIdHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(c) {
+    var mastra, runId, logs;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.prev = 0;
+          mastra = c.get('mastra');
+          runId = c.req.param('runId');
+          _context2.next = 5;
+          return mastra.getLogsByRunId(runId);
+        case 5:
+          logs = _context2.sent;
+          return _context2.abrupt("return", c.json(logs));
+        case 9:
+          _context2.prev = 9;
+          _context2.t0 = _context2["catch"](0);
+          return _context2.abrupt("return", handleError(_context2.t0, 'Error getting logs by run ID'));
+        case 12:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[0, 9]]);
+  }));
+  return _getLogsByRunIdHandler.apply(this, arguments);
+}
+
+// Memory handlers
+function getMemoryStatusHandler(_x) {
+  return _getMemoryStatusHandler.apply(this, arguments);
+}
+function _getMemoryStatusHandler() {
+  _getMemoryStatusHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(c) {
+    var mastra, memory;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          if (memory) {
+            _context.next = 5;
+            break;
+          }
+          return _context.abrupt("return", c.json({
+            result: false
+          }));
+        case 5:
+          return _context.abrupt("return", c.json({
+            result: true
+          }));
+        case 8:
+          _context.prev = 8;
+          _context.t0 = _context["catch"](0);
+          return _context.abrupt("return", handleError(_context.t0, 'Error getting memory status'));
+        case 11:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 8]]);
+  }));
+  return _getMemoryStatusHandler.apply(this, arguments);
+}
+function getThreadsHandler(_x2) {
+  return _getThreadsHandler.apply(this, arguments);
+}
+function _getThreadsHandler() {
+  _getThreadsHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(c) {
+    var mastra, memory, _c$req$query, resourceid, threads;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          _c$req$query = c.req.query(), resourceid = _c$req$query.resourceid;
+          if (memory) {
+            _context2.next = 6;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 6:
+          _context2.next = 8;
+          return memory.getThreadsByResourceId({
+            resourceid: resourceid
+          });
+        case 8:
+          threads = _context2.sent;
+          return _context2.abrupt("return", c.json(threads));
+        case 12:
+          _context2.prev = 12;
+          _context2.t0 = _context2["catch"](0);
+          return _context2.abrupt("return", handleError(_context2.t0, 'Error getting threads'));
+        case 15:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[0, 12]]);
+  }));
+  return _getThreadsHandler.apply(this, arguments);
+}
+function getThreadByIdHandler(_x3) {
+  return _getThreadByIdHandler.apply(this, arguments);
+}
+function _getThreadByIdHandler() {
+  _getThreadByIdHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(c) {
+    var mastra, memory, threadId, thread;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          threadId = c.req.param('threadId');
+          if (memory) {
+            _context3.next = 6;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 6:
+          _context3.next = 8;
+          return memory.getThreadById({
+            threadId: threadId
+          });
+        case 8:
+          thread = _context3.sent;
+          if (thread) {
+            _context3.next = 11;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Thread not found'
+          });
+        case 11:
+          return _context3.abrupt("return", c.json(thread));
+        case 14:
+          _context3.prev = 14;
+          _context3.t0 = _context3["catch"](0);
+          return _context3.abrupt("return", handleError(_context3.t0, 'Error getting thread'));
+        case 17:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[0, 14]]);
+  }));
+  return _getThreadByIdHandler.apply(this, arguments);
+}
+function saveMessagesHandler(_x4) {
+  return _saveMessagesHandler.apply(this, arguments);
+}
+function _saveMessagesHandler() {
+  _saveMessagesHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(c) {
+    var mastra, memory, _yield$c$req$json, messages, processedMessages, result;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          _context4.next = 5;
+          return c.req.json();
+        case 5:
+          _yield$c$req$json = _context4.sent;
+          messages = _yield$c$req$json.messages;
+          if (memory) {
+            _context4.next = 9;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 9:
+          validateBody({
+            messages: messages
+          });
+          if (Array.isArray(messages)) {
+            _context4.next = 12;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Messages should be an array'
+          });
+        case 12:
+          processedMessages = messages.map(function (message) {
+            return _extends({}, message, {
+              id: memory.generateId(),
+              createdAt: message.createdAt ? new Date(message.createdAt) : new Date()
+            });
+          });
+          _context4.next = 15;
+          return memory.saveMessages({
+            messages: processedMessages
+          });
+        case 15:
+          result = _context4.sent;
+          return _context4.abrupt("return", c.json(result));
+        case 19:
+          _context4.prev = 19;
+          _context4.t0 = _context4["catch"](0);
+          return _context4.abrupt("return", handleError(_context4.t0, 'Error saving messages'));
+        case 22:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[0, 19]]);
+  }));
+  return _saveMessagesHandler.apply(this, arguments);
+}
+function getContextWindowHandler(_x5) {
+  return _getContextWindowHandler.apply(this, arguments);
+}
+function _getContextWindowHandler() {
+  _getContextWindowHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(c) {
+    var mastra, memory, threadId, _c$req$query2, startDate, endDate, format, thread, result;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _context5.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          threadId = c.req.param('threadId');
+          _c$req$query2 = c.req.query(), startDate = _c$req$query2.startDate, endDate = _c$req$query2.endDate, format = _c$req$query2.format;
+          if (memory) {
+            _context5.next = 7;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 7:
+          _context5.next = 9;
+          return memory.getThreadById({
+            threadId: threadId
+          });
+        case 9:
+          thread = _context5.sent;
+          if (thread) {
+            _context5.next = 12;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Thread not found'
+          });
+        case 12:
+          _context5.next = 14;
+          return memory.getContextWindow({
+            threadId: threadId,
+            startDate: startDate,
+            endDate: endDate,
+            format: format
+          });
+        case 14:
+          result = _context5.sent;
+          return _context5.abrupt("return", c.json(result));
+        case 18:
+          _context5.prev = 18;
+          _context5.t0 = _context5["catch"](0);
+          return _context5.abrupt("return", handleError(_context5.t0, 'Error getting context window from memory'));
+        case 21:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5, null, [[0, 18]]);
+  }));
+  return _getContextWindowHandler.apply(this, arguments);
+}
+function createThreadHandler(_x6) {
+  return _createThreadHandler.apply(this, arguments);
+}
+function _createThreadHandler() {
+  _createThreadHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(c) {
+    var mastra, memory, _yield$c$req$json2, title, metadata, resourceid, threadId, result;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          _context6.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          _context6.next = 5;
+          return c.req.json();
+        case 5:
+          _yield$c$req$json2 = _context6.sent;
+          title = _yield$c$req$json2.title;
+          metadata = _yield$c$req$json2.metadata;
+          resourceid = _yield$c$req$json2.resourceid;
+          threadId = _yield$c$req$json2.threadId;
+          if (memory) {
+            _context6.next = 12;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 12:
+          validateBody({
+            resourceid: resourceid
+          });
+          _context6.next = 15;
+          return memory.createThread({
+            resourceid: resourceid,
+            title: title,
+            metadata: metadata,
+            threadId: threadId
+          });
+        case 15:
+          result = _context6.sent;
+          return _context6.abrupt("return", c.json(result));
+        case 19:
+          _context6.prev = 19;
+          _context6.t0 = _context6["catch"](0);
+          return _context6.abrupt("return", handleError(_context6.t0, 'Error saving thread to memory'));
+        case 22:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6, null, [[0, 19]]);
+  }));
+  return _createThreadHandler.apply(this, arguments);
+}
+function updateThreadHandler(_x7) {
+  return _updateThreadHandler.apply(this, arguments);
+}
+function _updateThreadHandler() {
+  _updateThreadHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(c) {
+    var mastra, memory, threadId, _yield$c$req$json3, title, metadata, resourceid, updatedAt, thread, updatedThread, result;
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          _context7.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          threadId = c.req.param('threadId');
+          _context7.next = 6;
+          return c.req.json();
+        case 6:
+          _yield$c$req$json3 = _context7.sent;
+          title = _yield$c$req$json3.title;
+          metadata = _yield$c$req$json3.metadata;
+          resourceid = _yield$c$req$json3.resourceid;
+          updatedAt = new Date();
+          if (memory) {
+            _context7.next = 13;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 13:
+          _context7.next = 15;
+          return memory.getThreadById({
+            threadId: threadId
+          });
+        case 15:
+          thread = _context7.sent;
+          if (thread) {
+            _context7.next = 18;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Thread not found'
+          });
+        case 18:
+          updatedThread = _extends({}, thread, {
+            title: title || thread.title,
+            metadata: metadata || thread.metadata,
+            resourceid: resourceid || thread.resourceid,
+            createdAt: thread.createdat,
+            updatedAt: updatedAt
+          });
+          _context7.next = 21;
+          return memory.saveThread({
+            thread: updatedThread
+          });
+        case 21:
+          result = _context7.sent;
+          return _context7.abrupt("return", c.json(result));
+        case 25:
+          _context7.prev = 25;
+          _context7.t0 = _context7["catch"](0);
+          return _context7.abrupt("return", handleError(_context7.t0, 'Error updating thread'));
+        case 28:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7, null, [[0, 25]]);
+  }));
+  return _updateThreadHandler.apply(this, arguments);
+}
+function deleteThreadHandler(_x8) {
+  return _deleteThreadHandler.apply(this, arguments);
+}
+function _deleteThreadHandler() {
+  _deleteThreadHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(c) {
+    var mastra, memory, threadId, thread;
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          _context8.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          threadId = c.req.param('threadId');
+          if (memory) {
+            _context8.next = 6;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 6:
+          _context8.next = 8;
+          return memory.getThreadById({
+            threadId: threadId
+          });
+        case 8:
+          thread = _context8.sent;
+          if (thread) {
+            _context8.next = 11;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Thread not found'
+          });
+        case 11:
+          _context8.next = 13;
+          return memory.deleteThread(threadId);
+        case 13:
+          return _context8.abrupt("return", c.json({
+            result: 'Thread deleted'
+          }));
+        case 16:
+          _context8.prev = 16;
+          _context8.t0 = _context8["catch"](0);
+          return _context8.abrupt("return", handleError(_context8.t0, 'Error deleting thread'));
+        case 19:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8, null, [[0, 16]]);
+  }));
+  return _deleteThreadHandler.apply(this, arguments);
+}
+function getMessagesHandler(_x9) {
+  return _getMessagesHandler.apply(this, arguments);
+}
+function _getMessagesHandler() {
+  _getMessagesHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee9(c) {
+    var mastra, memory, threadId, thread, result;
+    return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          _context9.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          threadId = c.req.param('threadId');
+          if (memory) {
+            _context9.next = 6;
+            break;
+          }
+          return _context9.abrupt("return", c.json({
+            error: 'Memory is not initialized'
+          }, 400));
+        case 6:
+          _context9.next = 8;
+          return memory.getThreadById({
+            threadId: threadId
+          });
+        case 8:
+          thread = _context9.sent;
+          if (thread) {
+            _context9.next = 11;
+            break;
+          }
+          return _context9.abrupt("return", c.json({
+            error: 'Thread not found'
+          }, 404));
+        case 11:
+          _context9.next = 13;
+          return memory.getMessages({
+            threadId: threadId
+          });
+        case 13:
+          result = _context9.sent;
+          return _context9.abrupt("return", c.json(result));
+        case 17:
+          _context9.prev = 17;
+          _context9.t0 = _context9["catch"](0);
+          return _context9.abrupt("return", handleError(_context9.t0, 'Error getting messages'));
+        case 20:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9, null, [[0, 17]]);
+  }));
+  return _getMessagesHandler.apply(this, arguments);
+}
+
+// Root handler
+function rootHandler(_x) {
+  return _rootHandler.apply(this, arguments);
+}
+function _rootHandler() {
+  _rootHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(c) {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", c.text('Hello to the Mastra API!'));
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _rootHandler.apply(this, arguments);
+}
+
+function executeSyncHandler(_x) {
+  return _executeSyncHandler.apply(this, arguments);
+}
+function _executeSyncHandler() {
+  _executeSyncHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(c) {
+    var mastra, syncId, _yield$c$req$json, runId, syncParams, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          mastra = c.get('mastra');
+          syncId = c.req.param('syncId');
+          _context.next = 5;
+          return c.req.json();
+        case 5:
+          _yield$c$req$json = _context.sent;
+          runId = _yield$c$req$json.runId;
+          syncParams = _yield$c$req$json.params;
+          validateBody({
+            params: syncParams
+          });
+          _context.next = 11;
+          return mastra.sync(syncId, syncParams, runId);
+        case 11:
+          result = _context.sent;
+          return _context.abrupt("return", c.json(result));
+        case 15:
+          _context.prev = 15;
+          _context.t0 = _context["catch"](0);
+          return _context.abrupt("return", handleError(_context.t0, 'Error executing sync'));
+        case 18:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 15]]);
+  }));
+  return _executeSyncHandler.apply(this, arguments);
+}
+
+// Tool handlers
+function getToolsHandler(_x) {
+  return _getToolsHandler.apply(this, arguments);
+}
+function _getToolsHandler() {
+  _getToolsHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(c) {
+    var tools, serializedTools;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.prev = 0;
+          tools = c.get('tools');
+          if (tools) {
+            _context2.next = 4;
+            break;
+          }
+          return _context2.abrupt("return", c.json({}));
+        case 4:
+          serializedTools = Object.entries(tools).reduce(function (acc, _ref2) {
+            var id = _ref2[0],
+              _tool = _ref2[1];
+            var tool = _tool;
+            acc[id] = _extends({}, tool, {
+              inputSchema: tool.inputSchema ? stringify(zodToJsonSchema(tool.inputSchema)) : undefined,
+              outputSchema: tool.outputSchema ? stringify(zodToJsonSchema(tool.outputSchema)) : undefined
+            });
+            return acc;
+          }, {});
+          return _context2.abrupt("return", c.json(serializedTools));
+        case 8:
+          _context2.prev = 8;
+          _context2.t0 = _context2["catch"](0);
+          return _context2.abrupt("return", handleError(_context2.t0, 'Error getting tools'));
+        case 11:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[0, 8]]);
+  }));
+  return _getToolsHandler.apply(this, arguments);
+}
+function getToolByIdHandler(_x2) {
+  return _getToolByIdHandler.apply(this, arguments);
+}
+function _getToolByIdHandler() {
+  _getToolByIdHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(c) {
+    var tools, toolId, tool, serializedTool;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.prev = 0;
+          tools = c.get('tools');
+          toolId = c.req.param('toolId');
+          tool = Object.values(tools || {}).find(function (tool) {
+            return tool.id === toolId;
+          });
+          if (tool) {
+            _context3.next = 6;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Tool not found'
+          });
+        case 6:
+          serializedTool = _extends({}, tool, {
+            inputSchema: tool.inputSchema ? stringify(zodToJsonSchema(tool.inputSchema)) : undefined,
+            outputSchema: tool.outputSchema ? stringify(zodToJsonSchema(tool.outputSchema)) : undefined
+          });
+          return _context3.abrupt("return", c.json(serializedTool));
+        case 10:
+          _context3.prev = 10;
+          _context3.t0 = _context3["catch"](0);
+          return _context3.abrupt("return", handleError(_context3.t0, 'Error getting tool'));
+        case 13:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[0, 10]]);
+  }));
+  return _getToolByIdHandler.apply(this, arguments);
+}
+function getToolResultHandler(_x3) {
+  return _getToolResultHandler.apply(this, arguments);
+}
+function _getToolResultHandler() {
+  _getToolResultHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(c) {
+    var mastra, memory, threadId, _yield$c$req$json2, toolName, toolArgs, thread, result;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          threadId = c.req.param('threadId');
+          _context4.next = 6;
+          return c.req.json();
+        case 6:
+          _yield$c$req$json2 = _context4.sent;
+          toolName = _yield$c$req$json2.toolName;
+          toolArgs = _yield$c$req$json2.toolArgs;
+          if (memory) {
+            _context4.next = 11;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 11:
+          validateBody({
+            toolName: toolName,
+            toolArgs: toolArgs
+          });
+          _context4.next = 14;
+          return memory.getThreadById({
+            threadId: threadId
+          });
+        case 14:
+          thread = _context4.sent;
+          if (thread) {
+            _context4.next = 17;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Thread not found'
+          });
+        case 17:
+          _context4.next = 19;
+          return memory.getToolResult({
+            threadId: threadId,
+            toolName: toolName,
+            toolArgs: toolArgs
+          });
+        case 19:
+          result = _context4.sent;
+          return _context4.abrupt("return", c.json(result));
+        case 23:
+          _context4.prev = 23;
+          _context4.t0 = _context4["catch"](0);
+          return _context4.abrupt("return", handleError(_context4.t0, 'Error getting tool result'));
+        case 26:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[0, 23]]);
+  }));
+  return _getToolResultHandler.apply(this, arguments);
+}
+function validateToolCallArgsHandler(_x4) {
+  return _validateToolCallArgsHandler.apply(this, arguments);
+}
+function _validateToolCallArgsHandler() {
+  _validateToolCallArgsHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(c) {
+    var mastra, memory, _yield$c$req$json3, hashedArgs, result;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _context5.prev = 0;
+          mastra = c.get('mastra');
+          memory = mastra.memory;
+          _context5.next = 5;
+          return c.req.json();
+        case 5:
+          _yield$c$req$json3 = _context5.sent;
+          hashedArgs = _yield$c$req$json3.hashedArgs;
+          if (memory) {
+            _context5.next = 9;
+            break;
+          }
+          throw new HTTPException(400, {
+            message: 'Memory is not initialized'
+          });
+        case 9:
+          validateBody({
+            hashedArgs: hashedArgs
+          });
+          _context5.next = 12;
+          return memory.validateToolCallArgs({
+            hashedArgs: hashedArgs
+          });
+        case 12:
+          result = _context5.sent;
+          return _context5.abrupt("return", c.json(result));
+        case 16:
+          _context5.prev = 16;
+          _context5.t0 = _context5["catch"](0);
+          return _context5.abrupt("return", handleError(_context5.t0, 'Error validating tool call args'));
+        case 19:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5, null, [[0, 16]]);
+  }));
+  return _validateToolCallArgsHandler.apply(this, arguments);
+}
+function executeToolHandler(tools) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(c) {
+      var toolId, tool, _yield$c$req$json, input, mastra, result;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            toolId = decodeURIComponent(c.req.param('toolId'));
+            tool = Object.values(tools || {}).find(function (tool) {
+              return tool.id === toolId;
+            });
+            if (tool) {
+              _context.next = 5;
+              break;
+            }
+            return _context.abrupt("return", c.json({
+              error: 'Tool not found'
+            }, 404));
+          case 5:
+            _context.next = 7;
+            return c.req.json();
+          case 7:
+            _yield$c$req$json = _context.sent;
+            input = _yield$c$req$json.input;
+            mastra = c.get('mastra');
+            _context.next = 12;
+            return tool.execute({
+              context: _extends({}, input),
+              mastra: mastra,
+              runId: mastra.runId
+            });
+          case 12:
+            result = _context.sent;
+            return _context.abrupt("return", c.json(result));
+          case 16:
+            _context.prev = 16;
+            _context.t0 = _context["catch"](0);
+            return _context.abrupt("return", handleError(_context.t0, 'Error executing tool'));
+          case 19:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 16]]);
+    }));
+    return function (_x5) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function executeAgentToolHandler(_x6) {
+  return _executeAgentToolHandler.apply(this, arguments);
+}
+function _executeAgentToolHandler() {
+  _executeAgentToolHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(c) {
+    var mastra, agentId, toolId, agent, tool, body, result;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          _context6.prev = 0;
+          mastra = c.get('mastra');
+          agentId = c.req.param('agentId');
+          toolId = c.req.param('toolId');
+          agent = mastra.getAgent(agentId);
+          tool = Object.values((agent == null ? void 0 : agent.tools) || {}).find(function (tool) {
+            return tool.id === toolId;
+          });
+          if (tool) {
+            _context6.next = 8;
+            break;
+          }
+          throw new HTTPException(404, {
+            message: 'Tool not found'
+          });
+        case 8:
+          _context6.next = 10;
+          return c.req.json();
+        case 10:
+          body = _context6.sent;
+          _context6.next = 13;
+          return tool.execute({
+            context: _extends({}, body),
+            mastra: mastra,
+            runId: agentId
+          });
+        case 13:
+          result = _context6.sent;
+          return _context6.abrupt("return", c.json(result));
+        case 17:
+          _context6.prev = 17;
+          _context6.t0 = _context6["catch"](0);
+          return _context6.abrupt("return", handleError(_context6.t0, 'Error executing tool'));
+        case 20:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6, null, [[0, 17]]);
+  }));
+  return _executeAgentToolHandler.apply(this, arguments);
+}
+
+function getWorkflowsHandler(_x) {
+  return _getWorkflowsHandler.apply(this, arguments);
+}
+function _getWorkflowsHandler() {
+  _getWorkflowsHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(c) {
+    var mastra, workflows;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          mastra = c.get('mastra');
+          workflows = mastra.getWorkflows({
+            serialized: true
+          });
+          return _context.abrupt("return", c.json(workflows));
+        case 6:
+          _context.prev = 6;
+          _context.t0 = _context["catch"](0);
+          return _context.abrupt("return", handleError(_context.t0, 'Error getting workflows'));
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 6]]);
+  }));
+  return _getWorkflowsHandler.apply(this, arguments);
+}
+function getWorkflowByIdHandler(_x2) {
+  return _getWorkflowByIdHandler.apply(this, arguments);
+}
+function _getWorkflowByIdHandler() {
+  _getWorkflowByIdHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(c) {
+    var mastra, workflowId, workflow, triggerSchema, stepGraph, stepSubscriberGraph, serializedSteps;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.prev = 0;
+          mastra = c.get('mastra');
+          workflowId = c.req.param('workflowId');
+          workflow = mastra.getWorkflow(workflowId);
+          triggerSchema = workflow.triggerSchema;
+          stepGraph = workflow.stepGraph;
+          stepSubscriberGraph = workflow.stepSubscriberGraph;
+          serializedSteps = Object.entries(workflow.steps).reduce(function (acc, _ref) {
+            var key = _ref[0],
+              step = _ref[1];
+            var _step = step;
+            acc[key] = _extends({}, _step, {
+              inputSchema: _step.inputSchema ? stringify(zodToJsonSchema(_step.inputSchema)) : undefined,
+              outputSchema: _step.outputSchema ? stringify(zodToJsonSchema(_step.outputSchema)) : undefined
+            });
+            return acc;
+          }, {});
+          return _context2.abrupt("return", c.json({
+            name: workflow.name,
+            triggerSchema: triggerSchema ? stringify(zodToJsonSchema(triggerSchema)) : undefined,
+            steps: serializedSteps,
+            stepGraph: stepGraph,
+            stepSubscriberGraph: stepSubscriberGraph
+          }));
+        case 11:
+          _context2.prev = 11;
+          _context2.t0 = _context2["catch"](0);
+          return _context2.abrupt("return", handleError(_context2.t0, 'Error getting workflow'));
+        case 14:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[0, 11]]);
+  }));
+  return _getWorkflowByIdHandler.apply(this, arguments);
+}
+function executeWorkflowHandler(_x3) {
+  return _executeWorkflowHandler.apply(this, arguments);
+}
+function _executeWorkflowHandler() {
+  _executeWorkflowHandler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(c) {
+    var mastra, workflowId, workflow, body, result;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.prev = 0;
+          mastra = c.get('mastra');
+          workflowId = c.req.param('workflowId');
+          workflow = mastra.getWorkflow(workflowId);
+          _context3.next = 6;
+          return c.req.json();
+        case 6:
+          body = _context3.sent;
+          _context3.next = 9;
+          return workflow.execute(body);
+        case 9:
+          result = _context3.sent;
+          return _context3.abrupt("return", c.json(result));
+        case 13:
+          _context3.prev = 13;
+          _context3.t0 = _context3["catch"](0);
+          return _context3.abrupt("return", handleError(_context3.t0, 'Error executing workflow'));
+        case 16:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[0, 13]]);
+  }));
+  return _executeWorkflowHandler.apply(this, arguments);
+}
+
+var html = "\n<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>Welcome to Mastra</title>\n    <link rel=\"stylesheet\" href=\"https://cdnjs.cloudflare.com/ajax/libs/inter-ui/3.19.3/inter.min.css\" />\n    <style>\n      body {\n        margin: 0;\n        padding: 0;\n        background-color: #0d0d0d;\n        color: #ffffff;\n        font-family:\n          'Inter',\n          -apple-system,\n          BlinkMacSystemFont,\n          system-ui,\n          sans-serif;\n        min-height: 100vh;\n        display: flex;\n        flex-direction: column;\n      }\n\n      main {\n        flex: 1;\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n        padding: 2rem;\n        text-align: center;\n      }\n\n      h1 {\n        font-size: 4rem;\n        font-weight: 600;\n        margin: 0 0 1rem 0;\n        background: linear-gradient(to right, #fff, #ccc);\n        -webkit-background-clip: text;\n        -webkit-text-fill-color: transparent;\n        line-height: 1.2;\n      }\n\n      .subtitle {\n        color: #9ca3af;\n        font-size: 1.25rem;\n        max-width: 600px;\n        margin: 0 auto 3rem auto;\n        line-height: 1.6;\n      }\n\n      .docs-link {\n        background-color: #1a1a1a;\n        padding: 1rem 2rem;\n        border-radius: 0.5rem;\n        display: flex;\n        align-items: center;\n        gap: 1rem;\n        font-family: monospace;\n        font-size: 1rem;\n        color: #ffffff;\n        text-decoration: none;\n        transition: background-color 0.2s;\n      }\n\n      .docs-link:hover {\n        background-color: #252525;\n      }\n\n      .arrow-icon {\n        transition: transform 0.2s;\n      }\n\n      .docs-link:hover .arrow-icon {\n        transform: translateX(4px);\n      }\n    </style>\n  </head>\n  <body>\n    <main>\n      <h1>Welcome to Mastra</h1>\n      <p class=\"subtitle\">\n        From the team that brought you Gatsby: prototype and productionize AI features with a modern JS/TS stack.\n      </p>\n\n      <a href=\"https://mastra.ai/docs\" class=\"docs-link\">\n        Browse the docs\n        <svg\n          class=\"arrow-icon\"\n          width=\"20\"\n          height=\"20\"\n          viewBox=\"0 0 24 24\"\n          fill=\"none\"\n          stroke=\"currentColor\"\n          stroke-width=\"2\"\n        >\n          <path d=\"M5 12h14M12 5l7 7-7 7\" />\n        </svg>\n      </a>\n    </main>\n  </body>\n</html>\n";
+
+function createHonoServer(_x, _x2) {
+  return _createHonoServer.apply(this, arguments);
+}
+function _createHonoServer() {
+  _createHonoServer = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(mastra, options) {
+    var _options;
+    var app, mastraToolsPaths, toolImports, tools;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          if (options === void 0) {
+            options = {};
+          }
+          // Create typed Hono app
+          app = new Hono(); // Initialize tools
+          mastraToolsPaths = process.env.MASTRA_TOOLS_PATH;
+          if (!mastraToolsPaths) {
+            _context5.next = 9;
+            break;
+          }
+          _context5.next = 6;
+          return Promise.all(mastraToolsPaths.split(',').map(/*#__PURE__*/function () {
+            var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(toolPath) {
+              return _regeneratorRuntime().wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    return _context.abrupt("return", import(pathToFileURL(toolPath).href));
+                  case 1:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee);
+            }));
+            return function (_x5) {
+              return _ref.apply(this, arguments);
+            };
+          }()));
+        case 6:
+          _context5.t0 = _context5.sent;
+          _context5.next = 10;
+          break;
+        case 9:
+          _context5.t0 = [];
+        case 10:
+          toolImports = _context5.t0;
+          tools = toolImports.reduce(function (acc, toolModule) {
+            Object.entries(toolModule).forEach(function (_ref2) {
+              var key = _ref2[0],
+                tool = _ref2[1];
+              acc[key] = tool;
+            });
+            return acc;
+          }, {}); // Middleware
+          app.use('*', cors());
+          // Add Mastra to context
+          app.use('*', /*#__PURE__*/function () {
+            var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(c, next) {
+              return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    c.set('mastra', mastra);
+                    c.set('tools', tools);
+                    _context2.next = 4;
+                    return next();
+                  case 4:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2);
+            }));
+            return function (_x6, _x7) {
+              return _ref3.apply(this, arguments);
+            };
+          }());
+          // API routes
+          app.get('/api', rootHandler);
+          // Agent routes
+          app.get('/api/agents', getAgentsHandler);
+          app.get('/api/agents/:agentId', getAgentByIdHandler);
+          app.post('/api/agents/:agentId/generate', generateHandler);
+          app.post('/api/agents/:agentId/stream', streamGenerateHandler);
+          app.post('/api/agents/:agentId/tools/:toolId/execute', executeAgentToolHandler);
+          // Memory routes
+          app.get('/api/memory/status', getMemoryStatusHandler);
+          app.get('/api/memory/threads', getThreadsHandler);
+          app.get('/api/memory/threads/:threadId', getThreadByIdHandler);
+          app.get('/api/memory/threads/:threadId/messages', getMessagesHandler);
+          app.get('/api/memory/threads/:threadId/context-window', getContextWindowHandler);
+          app.post('/api/memory/threads', createThreadHandler);
+          app.patch('/api/memory/threads/:threadId', updateThreadHandler);
+          app["delete"]('/api/memory/threads/:threadId', deleteThreadHandler);
+          app.post('/api/memory/save-messages', saveMessagesHandler);
+          app.post('/api/memory/threads/:threadId/tool-result', getToolResultHandler);
+          app.post('/api/memory/validate-tool-call-args', validateToolCallArgsHandler);
+          // Workflow routes
+          app.get('/api/workflows', getWorkflowsHandler);
+          app.get('/api/workflows/:workflowId', getWorkflowByIdHandler);
+          app.post('/api/workflows/:workflowId/execute', executeWorkflowHandler);
+          // Sync routes
+          app.post('/api/syncs/:syncId/execute', executeSyncHandler);
+          // Log routes
+          app.get('/api/logs', getLogsHandler);
+          app.get('/api/logs/:runId', getLogsByRunIdHandler);
+          // Tool routes
+          app.get('/api/tools', getToolsHandler);
+          app.get('/api/tools/:toolId', getToolByIdHandler);
+          app.post('/api/tools/:toolId/execute', executeToolHandler(tools));
+          // SSE endpoint for refresh notifications
+          app.get('/refresh-events', handleClientsRefresh);
+          // Trigger refresh for all clients
+          app.post('/__refresh', handleTriggerClientsRefresh);
+          if ((_options = options) != null && _options.playground) {
+            // Playground routes - these should come after API routes
+            // Serve assets with specific MIME types
+            app.use('/assets/*', /*#__PURE__*/function () {
+              var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(c, next) {
+                var path;
+                return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                  while (1) switch (_context3.prev = _context3.next) {
+                    case 0:
+                      path = c.req.path;
+                      if (path.endsWith('.js')) {
+                        c.header('Content-Type', 'application/javascript');
+                      } else if (path.endsWith('.css')) {
+                        c.header('Content-Type', 'text/css');
+                      }
+                      _context3.next = 4;
+                      return next();
+                    case 4:
+                    case "end":
+                      return _context3.stop();
+                  }
+                }, _callee3);
+              }));
+              return function (_x8, _x9) {
+                return _ref4.apply(this, arguments);
+              };
+            }());
+            // Serve assets from playground directory
+            app.use('/assets/*', serveStatic({
+              root: './playground/assets'
+            }));
+            // Serve static files from playground directory
+            app.use('*', serveStatic({
+              root: './playground'
+            }));
+          }
+          // Catch-all route to serve index.html for any non-API routes
+          app.get('*', /*#__PURE__*/function () {
+            var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(c, next) {
+              var _options2;
+              var indexHtml;
+              return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+                while (1) switch (_context4.prev = _context4.next) {
+                  case 0:
+                    if (!c.req.path.startsWith('/api/')) {
+                      _context4.next = 4;
+                      break;
+                    }
+                    _context4.next = 3;
+                    return next();
+                  case 3:
+                    return _context4.abrupt("return", _context4.sent);
+                  case 4:
+                    if (!((_options2 = options) != null && _options2.playground)) {
+                      _context4.next = 9;
+                      break;
+                    }
+                    _context4.next = 7;
+                    return readFile(join(process.cwd(), './playground/index.html'), 'utf-8');
+                  case 7:
+                    indexHtml = _context4.sent;
+                    return _context4.abrupt("return", c.newResponse(indexHtml, 200, {
+                      'Content-Type': 'text/html'
+                    }));
+                  case 9:
+                    return _context4.abrupt("return", c.newResponse(html, 200, {
+                      'Content-Type': 'text/html'
+                    }));
+                  case 10:
+                  case "end":
+                    return _context4.stop();
+                }
+              }, _callee4);
+            }));
+            return function (_x10, _x11) {
+              return _ref5.apply(this, arguments);
+            };
+          }());
+          return _context5.abrupt("return", app);
+        case 45:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return _createHonoServer.apply(this, arguments);
+}
+function createNodeServer(_x3, _x4) {
+  return _createNodeServer.apply(this, arguments);
+}
+function _createNodeServer() {
+  _createNodeServer = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(mastra, options) {
+    var app;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          if (options === void 0) {
+            options = {};
+          }
+          _context6.next = 3;
+          return createHonoServer(mastra, options);
+        case 3:
+          app = _context6.sent;
+          return _context6.abrupt("return", serve({
+            fetch: app.fetch,
+            port: Number(process.env.PORT) || 4111
+          }, function () {
+            console.log("\uD83E\uDD84 Server running on port " + (process.env.PORT || 4111) + "/api");
+            console.log("\uD83D\uDCDA Open API documentation available at http://localhost:" + (process.env.PORT || 4111) + "/openapi.json");
+            console.log("\uD83D\uDC68\u200D\uD83D\uDCBB Playground available at http://localhost:" + (process.env.PORT || 4111) + "/");
+          }));
+        case 5:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return _createNodeServer.apply(this, arguments);
+}
+
+export { Deployer, Deps, EnvService, FileEnvService, FileService, bundle, createHonoServer, createNodeServer, upsertMastraDir };
+//# sourceMappingURL=deployer.esm.js.map