@mastra/deployer 0.0.0-commonjs-20250227130920

package/dist/index.cjs

@@ -0,0 +1,1229 @@
+'use strict';
+
+var base = require('@mastra/core/base');
+var fs3 = require('fs');
+var path = require('path');
+var url = require('url');
+var fsExtra2 = require('fs-extra/esm');
+var fsPromises = require('fs/promises');
+var child_process = require('child_process');
+var stream = require('stream');
+var bundler = require('@mastra/core/bundler');
+var virtual = require('@rollup/plugin-virtual');
+var fsExtra = require('fs-extra');
+var commonjs = require('@rollup/plugin-commonjs');
+var json = require('@rollup/plugin-json');
+var nodeResolve2 = require('@rollup/plugin-node-resolve');
+var rollup = require('rollup');
+var esbuild = require('rollup-plugin-esbuild');
+var module$1 = require('module');
+var babel = require('@babel/core');
+var alias = require('@rollup/plugin-alias');
+var load = require('@neon-rs/load');
+var detectLibc = require('detect-libc');
+var helperModuleImports = require('@babel/helper-module-imports');
+var process$1 = require('process');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fsExtra2__default = /*#__PURE__*/_interopDefault(fsExtra2);
+var fsPromises__default = /*#__PURE__*/_interopDefault(fsPromises);
+var virtual__default = /*#__PURE__*/_interopDefault(virtual);
+var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
+var json__default = /*#__PURE__*/_interopDefault(json);
+var nodeResolve2__default = /*#__PURE__*/_interopDefault(nodeResolve2);
+var esbuild__default = /*#__PURE__*/_interopDefault(esbuild);
+var babel__namespace = /*#__PURE__*/_interopNamespace(babel);
+var alias__default = /*#__PURE__*/_interopDefault(alias);
+
+// src/build/deps.ts
+var createPinoStream = (logger) => {
+  return new stream.Transform({
+    transform(chunk, _encoding, callback) {
+      const line = chunk.toString().trim();
+      if (line) {
+        console.log(line);
+        logger.info(line);
+      }
+      callback(null, chunk);
+    }
+  });
+};
+function createChildProcessLogger({ logger, root }) {
+  const pinoStream = createPinoStream(logger);
+  return async ({ cmd, args, env }) => {
+    try {
+      const subprocess = child_process.spawn(cmd, args, {
+        cwd: root,
+        shell: true,
+        env
+      });
+      subprocess.stdout?.pipe(pinoStream);
+      subprocess.stderr?.pipe(pinoStream);
+      return new Promise((resolve2, reject) => {
+        subprocess.on("close", (code) => {
+          pinoStream.end();
+          if (code === 0) {
+            resolve2({ success: true });
+          } else {
+            reject(new Error(`Process exited with code ${code}`));
+          }
+        });
+        subprocess.on("error", (error) => {
+          pinoStream.end();
+          logger.error("Process failed", { error });
+          reject(error);
+        });
+      });
+    } catch (error) {
+      console.log(error);
+      logger.error("Process failed", { error });
+      pinoStream.end();
+      return { success: false, error };
+    }
+  };
+}
+
+// src/build/deps.ts
+var Deps = class extends base.MastraBase {
+  packageManager;
+  rootDir;
+  constructor(rootDir = process.cwd()) {
+    super({ component: "DEPLOYER", name: "DEPS" });
+    this.rootDir = rootDir;
+    this.packageManager = this.getPackageManager();
+  }
+  findLockFile(dir) {
+    const lockFiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"];
+    for (const file of lockFiles) {
+      if (fs3__namespace.default.existsSync(path__default.default.join(dir, file))) {
+        return file;
+      }
+    }
+    const parentDir = path__default.default.resolve(dir, "..");
+    if (parentDir !== dir) {
+      return this.findLockFile(parentDir);
+    }
+    return null;
+  }
+  getPackageManager() {
+    const lockFile = this.findLockFile(this.rootDir);
+    switch (lockFile) {
+      case "pnpm-lock.yaml":
+        return "pnpm";
+      case "package-lock.json":
+        return "npm";
+      case "yarn.lock":
+        return "yarn";
+      case "bun.lock":
+        return "bun";
+      default:
+        return "npm";
+    }
+  }
+  async install({ dir = this.rootDir, packages = [] }) {
+    let runCommand = this.packageManager;
+    if (this.packageManager === "npm") {
+      runCommand = `${this.packageManager} i`;
+    } else {
+      runCommand = `${this.packageManager} ${packages?.length > 0 ? `add` : `install`}`;
+    }
+    const cpLogger = createChildProcessLogger({
+      logger: this.logger,
+      root: dir
+    });
+    return cpLogger({
+      cmd: runCommand,
+      args: packages,
+      env: {
+        PATH: process.env.PATH
+      }
+    });
+  }
+  async installPackages(packages) {
+    let runCommand = this.packageManager;
+    if (this.packageManager === "npm") {
+      runCommand = `${this.packageManager} i`;
+    } else {
+      runCommand = `${this.packageManager} add`;
+    }
+    const cpLogger = createChildProcessLogger({
+      logger: this.logger,
+      root: ""
+    });
+    return cpLogger({
+      cmd: `${runCommand}`,
+      args: packages,
+      env: {
+        PATH: process.env.PATH
+      }
+    });
+  }
+  async checkDependencies(dependencies) {
+    try {
+      const packageJsonPath = path__default.default.join(this.rootDir, "package.json");
+      try {
+        await fsPromises__default.default.access(packageJsonPath);
+      } catch {
+        return "No package.json file found in the current directory";
+      }
+      const packageJson = JSON.parse(await fsPromises__default.default.readFile(packageJsonPath, "utf-8"));
+      for (const dependency of dependencies) {
+        if (!packageJson.dependencies || !packageJson.dependencies[dependency]) {
+          return `Please install ${dependency} before running this command (${this.packageManager} install ${dependency})`;
+        }
+      }
+      return "ok";
+    } catch (err) {
+      console.error(err);
+      return "Could not check dependencies";
+    }
+  }
+  async getProjectName() {
+    try {
+      const packageJsonPath = path__default.default.join(this.rootDir, "package.json");
+      const packageJson = await fsPromises__default.default.readFile(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(packageJson);
+      return pkg.name;
+    } catch (err) {
+      throw err;
+    }
+  }
+  async getPackageVersion() {
+    const __filename = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    const __dirname = path.dirname(__filename);
+    const pkgJsonPath = path__default.default.join(__dirname, "..", "..", "package.json");
+    const content = await fsExtra2__default.default.readJSON(pkgJsonPath);
+    return content.version;
+  }
+  async addScriptsToPackageJson(scripts) {
+    const packageJson = JSON.parse(await fsPromises__default.default.readFile("package.json", "utf-8"));
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      ...scripts
+    };
+    await fsPromises__default.default.writeFile("package.json", JSON.stringify(packageJson, null, 2));
+  }
+};
+var EnvService = class {
+};
+var FileEnvService = class extends EnvService {
+  filePath;
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
+  }
+  readFile(filePath) {
+    return new Promise((resolve2, reject) => {
+      fs3__namespace.readFile(filePath, "utf8", (err, data) => {
+        if (err) reject(err);
+        else resolve2(data);
+      });
+    });
+  }
+  writeFile({ filePath, data }) {
+    return new Promise((resolve2, reject) => {
+      fs3__namespace.writeFile(filePath, data, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve2();
+      });
+    });
+  }
+  async updateEnvData({
+    key,
+    value,
+    filePath = this.filePath,
+    data
+  }) {
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (data.match(regex)) {
+      data = data.replace(regex, `${key}=${value}`);
+    } else {
+      data += `
+${key}=${value}`;
+    }
+    await this.writeFile({ filePath, data });
+    console.log(`${key} set to ${value} in ENV file.`);
+    return data;
+  }
+  async getEnvValue(key) {
+    try {
+      const data = await this.readFile(this.filePath);
+      const regex = new RegExp(`^${key}=(.*)$`, "m");
+      const match = data.match(regex);
+      return match?.[1] || null;
+    } catch (err) {
+      console.error(`Error reading ENV value: ${err}`);
+      return null;
+    }
+  }
+  async setEnvValue(key, value) {
+    try {
+      const data = await this.readFile(this.filePath);
+      await this.updateEnvData({ key, value, data });
+    } catch (err) {
+      console.error(`Error writing ENV value: ${err}`);
+    }
+  }
+};
+
+// src/build/fs.ts
+var FileService = class {
+  /**
+   *
+   * @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
+   */
+  async copyStarterFile(inputFile, outputFilePath, replaceIfExists) {
+    const __filename = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    const __dirname = path__default.default.dirname(__filename);
+    const filePath = path__default.default.resolve(__dirname, "..", "starter-files", inputFile);
+    const fileString = fs3__namespace.default.readFileSync(filePath, "utf8");
+    if (fs3__namespace.default.existsSync(outputFilePath) && !replaceIfExists) {
+      console.log(`${outputFilePath} already exists`);
+      return false;
+    }
+    await fsExtra2__default.default.outputFile(outputFilePath, fileString);
+    return true;
+  }
+  async setupEnvFile({ dbUrl }) {
+    const envPath = path__default.default.join(process.cwd(), ".env.development");
+    await fsExtra2__default.default.ensureFile(envPath);
+    const fileEnvService = new FileEnvService(envPath);
+    await fileEnvService.setEnvValue("DB_URL", dbUrl);
+  }
+  getFirstExistingFile(files) {
+    for (const f of files) {
+      if (fs3__namespace.default.existsSync(f)) {
+        return f;
+      }
+    }
+    throw new Error("Missing required file, checked the following paths: " + files.join(", "));
+  }
+  replaceValuesInFile({
+    filePath,
+    replacements
+  }) {
+    let fileContent = fs3__namespace.default.readFileSync(filePath, "utf8");
+    replacements.forEach(({ search, replace }) => {
+      fileContent = fileContent.replaceAll(search, replace);
+    });
+    fs3__namespace.default.writeFileSync(filePath, fileContent);
+  }
+};
+function isNodeBuiltin(dep) {
+  const [pkg] = dep.split("/");
+  return dep.startsWith("node:") || module$1.builtinModules.includes(dep) || module$1.builtinModules.includes(pkg);
+}
+function aliasHono() {
+  return {
+    name: "hono-alias",
+    resolveId(id) {
+      if (!id.startsWith("@hono/") && !id.startsWith("hono/") && id !== "hono" && id !== "hono-openapi") {
+        return;
+      }
+      const path3 = undefined(id);
+      return url.fileURLToPath(path3);
+    }
+  };
+}
+
+// src/build/plugins/pino.ts
+function pino() {
+  const workerFiles = [
+    {
+      id: "thread-stream-worker",
+      file: "pino-thread-stream-worker"
+    },
+    {
+      id: "pino-worker",
+      file: "pino-worker"
+    },
+    {
+      id: "pino/file",
+      file: "pino-file"
+    },
+    {
+      id: "pino-pretty",
+      file: "pino-pretty"
+    }
+  ];
+  const fileReferences = /* @__PURE__ */ new Map();
+  return {
+    name: "rollup-plugin-pino",
+    async resolveId(id, importee) {
+      if (id === "pino") {
+        const resolvedPino = await this.resolve(id, importee);
+        if (resolvedPino) {
+          await Promise.all(
+            workerFiles.map(async (file) => {
+              const resolvedEntry = await this.resolve(file.id, resolvedPino.id);
+              if (!resolvedEntry) {
+                return null;
+              }
+              const reference = this.emitFile({
+                type: "chunk",
+                id: resolvedEntry.id,
+                name: `${file.file}`
+              });
+              fileReferences.set(file.id, reference);
+            })
+          );
+        }
+      }
+    },
+    renderChunk(code, chunk) {
+      if (chunk.type === "chunk" && chunk.isEntry && fileReferences.size && chunk.name === "index") {
+        const importRegex = /^(?:import(?:["'\s]*[\w*${}\n\r\t, ]+from\s*)?["'\s].+[;"'\s]*)$/gm;
+        const codeToInject = `globalThis.__bundlerPathsOverrides = {
+            ${Array.from(fileReferences.entries()).map(([key, file]) => {
+          return '"' + key + '": import.meta.ROLLUP_FILE_URL_' + file;
+        }).join(",\n")}
+            };`;
+        const matches = Array.from(code.matchAll(importRegex));
+        if (matches.length > 0) {
+          const lastImport = matches[matches.length - 1];
+          const lastImportEnd = lastImport.index + lastImport[0].length;
+          const newCode = code.slice(0, lastImportEnd) + "\n\n" + codeToInject + "\n\n" + code.slice(lastImportEnd);
+          return {
+            code: newCode,
+            map: null
+          };
+        }
+        return {
+          code: `${codeToInject}
+
+${code}`,
+          map: null
+        };
+      }
+    }
+  };
+}
+function removeDeployer() {
+  const t = babel__namespace.default.types;
+  let mastraClass = null;
+  return {
+    name: "remove-deployer",
+    visitor: {
+      ImportDeclaration(path3) {
+        if ((path3.node.source.value === "@mastra/core" || path3.node.source.value === "@mastra/core/mastra") && path3.node.specifiers) {
+          const mastraObj = path3.node.specifiers.find(
+            (p) => t.isImportSpecifier(p) && t.isIdentifier(p.imported) && p.imported.name === "Mastra"
+          );
+          if (mastraObj?.local?.name) {
+            mastraClass = mastraObj.local.name;
+          }
+        }
+      },
+      NewExpression(path3, state) {
+        if (mastraClass && t.isIdentifier(path3.node.callee) && path3.node.callee.name === mastraClass && !state.hasReplaced) {
+          state.hasReplaced = true;
+          const newMastraObj = t.cloneNode(path3.node);
+          if (t.isObjectExpression(newMastraObj.arguments[0]) && newMastraObj.arguments[0].properties?.[0]) {
+            newMastraObj.arguments[0].properties = newMastraObj.arguments[0].properties.filter(
+              (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name !== "deployer"
+            );
+            path3.replaceWith(newMastraObj);
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/build/plugins/remove-deployer.ts
+function removeDeployer2(mastraEntry) {
+  return {
+    name: "remove-deployer",
+    transform(code, id) {
+      if (id !== mastraEntry) {
+        return;
+      }
+      return new Promise((resolve2, reject) => {
+        babel__namespace.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [removeDeployer]
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+            resolve2({
+              code: result.code,
+              map: result.map
+            });
+          }
+        );
+      });
+    }
+  };
+}
+
+// src/build/analyze.ts
+async function analyze(entry, mastraEntry, isVirtualFile, platform2, logger) {
+  logger.info("Analyzing dependencies...");
+  let virtualPlugin = null;
+  if (isVirtualFile) {
+    virtualPlugin = virtual__default.default({
+      "#entry": entry
+    });
+    entry = "#entry";
+  }
+  const optimizerBundler = await rollup.rollup({
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    input: isVirtualFile ? "#entry" : entry,
+    treeshake: true,
+    preserveSymlinks: true,
+    plugins: [
+      virtualPlugin,
+      {
+        name: "custom-alias-resolver",
+        resolveId(id) {
+          if (id === "#server") {
+            return url.fileURLToPath(undefined("@mastra/deployer/server")).replaceAll("\\", "/");
+          }
+          if (id === "#mastra") {
+            return mastraEntry.replaceAll("\\", "/");
+          }
+        }
+      },
+      json__default.default(),
+      commonjs__default.default({
+        strictRequires: "debug",
+        ignoreTryCatch: false,
+        transformMixedEsModules: true,
+        extensions: [".js", ".ts"]
+      }),
+      esbuild__default.default({
+        target: "node20",
+        platform: platform2,
+        minify: false
+      }),
+      removeDeployer2(mastraEntry),
+      esbuild__default.default({
+        target: "node20",
+        platform: platform2,
+        minify: false
+      })
+    ].filter(Boolean)
+  });
+  const { output } = await optimizerBundler.generate({
+    format: "esm",
+    inlineDynamicImports: true
+  });
+  await optimizerBundler.close();
+  const depsToOptimize = new Map(Object.entries(output[0].importedBindings));
+  for (const dep of depsToOptimize.keys()) {
+    if (isNodeBuiltin(dep)) {
+      depsToOptimize.delete(dep);
+    }
+  }
+  return depsToOptimize;
+}
+async function bundleExternals(depsToOptimize, outputDir, logger) {
+  logger.info("Optimizing dependencies...");
+  logger.debug(
+    `${Array.from(depsToOptimize.keys()).map((key) => `- ${key}`).join("\n")}`
+  );
+  const reverseVirtualReferenceMap = /* @__PURE__ */ new Map();
+  const virtualDependencies = /* @__PURE__ */ new Map();
+  for (const [dep, exports] of depsToOptimize.entries()) {
+    const name = dep.replaceAll("/", "-");
+    reverseVirtualReferenceMap.set(name, dep);
+    const virtualFile = [];
+    let exportStringBuilder = [];
+    for (const local of exports) {
+      if (local === "*") {
+        virtualFile.push(`export * from '${dep}';`);
+      } else if (local === "default") {
+        virtualFile.push(`export * from '${dep}';`);
+      } else {
+        exportStringBuilder.push(local);
+      }
+    }
+    if (exportStringBuilder.length > 0) {
+      virtualFile.push(`export { ${exportStringBuilder.join(", ")} } from '${dep}';`);
+    }
+    virtualDependencies.set(dep, {
+      name,
+      virtual: virtualFile.join("\n")
+    });
+  }
+  const bundler = await rollup.rollup({
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    input: Array.from(virtualDependencies.entries()).reduce(
+      (acc, [dep, virtualDep]) => {
+        acc[virtualDep.name] = `#virtual-${dep}`;
+        return acc;
+      },
+      {}
+    ),
+    // this dependency breaks the build, so we need to exclude it
+    // TODO actually fix this so we don't need to exclude it
+    external: ["jsdom"],
+    treeshake: "smallest",
+    preserveSymlinks: true,
+    plugins: [
+      virtual__default.default(
+        Array.from(virtualDependencies.entries()).reduce(
+          (acc, [dep, virtualDep]) => {
+            acc[`#virtual-${dep}`] = virtualDep.virtual;
+            return acc;
+          },
+          {}
+        )
+      ),
+      pino(),
+      commonjs__default.default({
+        strictRequires: "strict",
+        transformMixedEsModules: true,
+        ignoreTryCatch: false
+      }),
+      nodeResolve2__default.default({
+        preferBuiltins: true,
+        exportConditions: ["node", "import", "require"],
+        mainFields: ["module", "main"]
+      }),
+      // hono is imported from deployer, so we need to resolve from here instead of the project root
+      aliasHono(),
+      json__default.default()
+    ].filter(Boolean)
+  });
+  const { output } = await bundler.write({
+    format: "esm",
+    dir: outputDir,
+    entryFileNames: "[name].mjs",
+    chunkFileNames: "[name].mjs"
+  });
+  await bundler.close();
+  return { output, reverseVirtualReferenceMap };
+}
+async function validateOutput(output, reverseVirtualReferenceMap, outputDir, logger) {
+  const result = {
+    invalidChunks: /* @__PURE__ */ new Set(),
+    dependencies: /* @__PURE__ */ new Map(),
+    externalDependencies: /* @__PURE__ */ new Set()
+  };
+  for (const file of output) {
+    if (file.type === "asset") {
+      continue;
+    }
+    try {
+      logger.debug(`Validating if ${file.fileName} is a valid module.`);
+      if (file.isEntry && reverseVirtualReferenceMap.has(file.name)) {
+        result.dependencies.set(reverseVirtualReferenceMap.get(file.name), file.fileName);
+      }
+      await import(`file:${outputDir}/${file.fileName}`);
+    } catch (err) {
+      result.invalidChunks.add(file.fileName);
+      if (file.isEntry && reverseVirtualReferenceMap.has(file.name)) {
+        result.externalDependencies.add(reverseVirtualReferenceMap.get(file.name));
+      }
+    }
+  }
+  return result;
+}
+async function analyzeBundle(entry, mastraEntry, outputDir, platform2, logger) {
+  const isVirtualFile = entry.includes("\n") || !fs3.existsSync(entry);
+  const depsToOptimize = await analyze(entry, mastraEntry, isVirtualFile, platform2, logger);
+  const { output, reverseVirtualReferenceMap } = await bundleExternals(depsToOptimize, outputDir, logger);
+  const result = await validateOutput(output, reverseVirtualReferenceMap, outputDir, logger);
+  return result;
+}
+function rewriteLibsqlImport() {
+  const t = babel__namespace.default.types;
+  let hasReplaced = false;
+  return {
+    name: "rewrite-libsql-import",
+    visitor: {
+      FunctionDeclaration(path3) {
+        if (path3.node.id?.name === "requireNative" && !hasReplaced) {
+          hasReplaced = true;
+          const createRequire = helperModuleImports.addNamed(path3, "createRequire", "module");
+          const requireIdentifier = t.identifier("require");
+          path3.replaceWith(
+            t.functionDeclaration(
+              t.identifier("requireNative"),
+              [],
+              t.blockStatement([
+                t.variableDeclaration("const", [
+                  t.variableDeclarator(
+                    requireIdentifier,
+                    t.callExpression(createRequire, [
+                      t.memberExpression(
+                        t.metaProperty(t.identifier("import"), t.identifier("meta")),
+                        t.identifier("url")
+                      )
+                    ])
+                  )
+                ]),
+                t.returnStatement(t.callExpression(requireIdentifier, [t.stringLiteral("./libsql.node")]))
+              ])
+            )
+          );
+        }
+      }
+    }
+  };
+}
+
+// src/build/plugins/fix-libsql.ts
+function libSqlFix() {
+  return {
+    name: "libSqlFix",
+    transform(code, id) {
+      if (!id.includes("\\libsql\\index.js") && !id.includes("/libsql/index.js")) {
+        return null;
+      }
+      return new Promise((resolve2, reject) => {
+        babel__namespace.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [rewriteLibsqlImport]
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+            resolve2({
+              code: result.code,
+              map: result.map
+            });
+          }
+        );
+      });
+    },
+    async generateBundle({ file, dir }) {
+      if (!file && !dir) {
+        throw new Error("No output options were given.");
+      }
+      const outputDirectory = dir || path.dirname(file);
+      let target = load.currentTarget();
+      if (detectLibc.familySync() == detectLibc.GLIBC) {
+        switch (target) {
+          case "linux-x64-musl":
+            target = "linux-x64-gnu";
+            break;
+          case "linux-arm64-musl":
+            target = "linux-arm64-gnu";
+            break;
+        }
+      }
+      const fileToCopy = await this.resolve(`@libsql/${target}/index.node`);
+      if (fileToCopy) {
+        await fsExtra2__default.default.copy(fileToCopy.id, path.join(outputDirectory, "libsql.node"));
+      }
+    }
+  };
+}
+function getTelemetryMachineFile() {
+  switch (process$1.platform) {
+    case "darwin":
+      return "getMachineId-darwin";
+    case "linux":
+      return "getMachineId-linux";
+    case "freebsd":
+      return "getMachineId-bsd";
+    case "win32":
+      return "getMachineId-win";
+    default:
+      return "getMachineId-unsupported";
+  }
+}
+function telemetryFix() {
+  return {
+    name: "telemetry-fix",
+    transform(code, id) {
+      if (id.includes("require-in-the-middle")) {
+        return code.replace(
+          `const path = require('path')`,
+          `const path = require('path');
+      const { createRequire } = require('module');
+      const realRequire = createRequire(import.meta.url)`
+        ).replaceAll(`require.resolve`, `realRequire.resolve`);
+      }
+    },
+    resolveId(id, importer) {
+      if (id === "./machine-id/getMachineId" && importer) {
+        return { id: path.resolve(path.dirname(importer), `./machine-id/${getTelemetryMachineFile()}.js`) };
+      }
+      if (id === "formdata-node") {
+        return { id: "formdata-node", external: false };
+      }
+    },
+    load(id) {
+      if (id.startsWith("formdata-node")) {
+        return "export default {};";
+      }
+      return null;
+    }
+  };
+}
+
+// src/build/bundler.ts
+async function getInputOptions(entryFile, analyzedBundleInfo, platform2) {
+  let nodeResolvePlugin = nodeResolve2__default.default({
+    preferBuiltins: true,
+    exportConditions: ["node", "import", "require"],
+    mainFields: ["module", "main"]
+  }) ;
+  const externals = Array.from(analyzedBundleInfo.externalDependencies).concat(["@mastra/core/hooks"]);
+  return {
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    treeshake: true,
+    preserveSymlinks: true,
+    external: externals,
+    plugins: [
+      telemetryFix(),
+      libSqlFix(),
+      {
+        name: "alias-optimized-deps",
+        // @ts-ignore
+        resolveId(id) {
+          if (!analyzedBundleInfo.dependencies.has(id)) {
+            return null;
+          }
+          const isInvalidChunk = analyzedBundleInfo.invalidChunks.has(analyzedBundleInfo.dependencies.get(id));
+          if (isInvalidChunk) {
+            return {
+              id,
+              external: true
+            };
+          }
+          return {
+            id: ".mastra/.build/" + analyzedBundleInfo.dependencies.get(id),
+            external: false
+          };
+        }
+      },
+      alias__default.default({
+        entries: [
+          {
+            find: /^\#server$/,
+            replacement: url.fileURLToPath(undefined("@mastra/deployer/server")).replaceAll("\\", "/")
+          },
+          { find: /^\#mastra$/, replacement: entryFile.replaceAll("\\", "/") }
+        ]
+      }),
+      esbuild__default.default({
+        target: "node20",
+        platform: platform2,
+        minify: false,
+        define: {
+          "process.env.NODE_ENV": JSON.stringify("production")
+        }
+      }),
+      commonjs__default.default({
+        extensions: [".js", ".ts"],
+        transformMixedEsModules: true,
+        esmExternals(id) {
+          return externals.includes(id);
+        }
+      }),
+      nodeResolvePlugin,
+      // for debugging
+      // {
+      //   name: 'logger',
+      //   //@ts-ignore
+      //   resolveId(id, ...args) {
+      //     console.log({ id, args });
+      //   },
+      //   // @ts-ignore
+      // transform(code, id) {
+      //   if (code.includes('class Duplexify ')) {
+      //     console.log({ duplex: id });
+      //   }
+      // },
+      // },
+      json__default.default(),
+      removeDeployer2(entryFile),
+      // treeshake unused imports
+      esbuild__default.default({
+        include: entryFile,
+        target: "node20",
+        platform: platform2,
+        minify: false
+      })
+    ].filter(Boolean)
+  };
+}
+async function createBundler(inputOptions, outputOptions) {
+  const bundler = await rollup.rollup(inputOptions);
+  return {
+    write: () => {
+      return bundler.write({
+        ...outputOptions,
+        format: "esm",
+        entryFileNames: "[name].mjs",
+        chunkFileNames: "[name].mjs"
+      });
+    },
+    close: () => {
+      return bundler.close();
+    }
+  };
+}
+function removeAllExceptTelemetryConfig(result) {
+  let mastraClass = null;
+  const t = babel__namespace.default.types;
+  return {
+    name: "remove-all-except-telemetry-config",
+    visitor: {
+      ExportNamedDeclaration: {
+        // remove all exports
+        exit(path3) {
+          path3.remove();
+        }
+      },
+      ImportDeclaration(path3) {
+        if ((path3.node.source.value === "@mastra/core" || path3.node.source.value === "@mastra/core/mastra") && path3.node.specifiers) {
+          mastraClass = path3.node.specifiers.find(
+            // @ts-ignore - no need to type
+            (p) => p.imported?.name === "Mastra"
+          )?.local?.name ?? null;
+        }
+      },
+      NewExpression(path3) {
+        if (mastraClass && path3.node.callee.name === mastraClass) {
+          let telemetry = path3.node.arguments[0]?.properties?.find(
+            // @ts-ignore
+            (prop) => prop.key.name === "telemetry"
+          );
+          const programPath = path3.scope.getProgramParent().path;
+          if (!programPath) {
+            return;
+          }
+          if (telemetry) {
+            result.hasCustomConfig = true;
+          } else {
+            telemetry = {
+              value: t.objectExpression([])
+            };
+          }
+          const exportDeclaration = t.exportNamedDeclaration(
+            t.variableDeclaration("const", [t.variableDeclarator(t.identifier("telemetry"), telemetry.value)]),
+            []
+          );
+          programPath.node.body.push(exportDeclaration);
+        }
+      }
+    }
+  };
+}
+
+// src/build/telemetry.ts
+async function writeTelemetryConfig(entryFile, outputDir) {
+  const result = {
+    hasCustomConfig: false
+  };
+  const bundle = await rollup.rollup({
+    input: {
+      "telemetry-config": entryFile
+    },
+    treeshake: true,
+    plugins: [
+      // transpile typescript to something we understand
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      {
+        name: "get-telemetry-config",
+        transform(code, id) {
+          if (!this.getModuleInfo(id)?.isEntry) {
+            return;
+          }
+          return new Promise((resolve2, reject) => {
+            babel__namespace.transform(
+              code,
+              {
+                babelrc: false,
+                configFile: false,
+                filename: id,
+                plugins: [removeAllExceptTelemetryConfig(result)]
+              },
+              (err, result2) => {
+                if (err) {
+                  return reject(err);
+                }
+                resolve2({
+                  code: result2.code,
+                  map: result2.map
+                });
+              }
+            );
+          });
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      })
+    ]
+  });
+  await bundle.write({
+    dir: outputDir,
+    format: "es",
+    entryFileNames: "[name].mjs"
+  });
+  return result;
+}
+
+// src/bundler/index.ts
+var Bundler = class extends bundler.MastraBundler {
+  analyzeOutputDir = ".build";
+  outputDir = "output";
+  constructor(name, component = "BUNDLER") {
+    super({ name, component });
+  }
+  async prepare(outputDirectory) {
+    await fsExtra2__default.default.emptyDir(outputDirectory);
+    await fsExtra.ensureDir(path.join(outputDirectory, this.analyzeOutputDir));
+    await fsExtra.ensureDir(path.join(outputDirectory, this.outputDir));
+  }
+  async writeInstrumentationFile(outputDirectory) {
+    const instrumentationFile = path.join(outputDirectory, "instrumentation.mjs");
+    const __dirname = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+    await fsExtra.copy(path.join(__dirname, "templates", "instrumentation-template.js"), instrumentationFile);
+  }
+  async writePackageJson(outputDirectory, dependencies) {
+    this.logger.debug(`Writing project's package.json`);
+    await fsExtra.ensureDir(outputDirectory);
+    const pkgPath = path.join(outputDirectory, "package.json");
+    const dependenciesMap = /* @__PURE__ */ new Map();
+    for (const [key, value] of dependencies.entries()) {
+      if (key.startsWith("@")) {
+        const pkgChunks = key.split("/");
+        dependenciesMap.set(`${pkgChunks[0]}/${pkgChunks[1]}`, value);
+        continue;
+      }
+      dependenciesMap.set(key, value);
+    }
+    dependenciesMap.set("@opentelemetry/instrumentation", "latest");
+    await fsPromises.writeFile(
+      pkgPath,
+      JSON.stringify(
+        {
+          name: "server",
+          version: "1.0.0",
+          description: "",
+          type: "module",
+          main: "index.mjs",
+          scripts: {
+            start: "node ./index.mjs"
+          },
+          author: "Mastra",
+          license: "ISC",
+          dependencies: Object.fromEntries(dependenciesMap.entries())
+        },
+        null,
+        2
+      )
+    );
+  }
+  createBundler(inputOptions, outputOptions) {
+    return createBundler(inputOptions, outputOptions);
+  }
+  async analyze(entry, mastraFile, outputDirectory) {
+    return await analyzeBundle(entry, mastraFile, path.join(outputDirectory, this.analyzeOutputDir), "node", this.logger);
+  }
+  async installDependencies(outputDirectory, rootDir = process.cwd()) {
+    const deps = new Deps(rootDir);
+    deps.__setLogger(this.logger);
+    await deps.install({ dir: path.join(outputDirectory, this.outputDir) });
+  }
+  async _bundle(serverFile, mastraEntryFile, outputDirectory, bundleLocation = path.join(outputDirectory, this.outputDir)) {
+    this.logger.info("Start bundling Mastra");
+    const isVirtual = serverFile.includes("\n") || fs3.existsSync(serverFile);
+    const analyzedBundleInfo = await analyzeBundle(
+      serverFile,
+      mastraEntryFile,
+      path.join(outputDirectory, this.analyzeOutputDir),
+      "node",
+      this.logger
+    );
+    await writeTelemetryConfig(mastraEntryFile, path.join(outputDirectory, this.outputDir));
+    const dependenciesToInstall = Array.from(analyzedBundleInfo.externalDependencies).reduce((acc, dep) => {
+      acc.set(dep, "latest");
+      return acc;
+    }, /* @__PURE__ */ new Map());
+    await this.writePackageJson(path.join(outputDirectory, this.outputDir), dependenciesToInstall);
+    await this.writeInstrumentationFile(path.join(outputDirectory, this.outputDir));
+    this.logger.info("Bundling Mastra application");
+    const inputOptions = await getInputOptions(mastraEntryFile, analyzedBundleInfo, "node");
+    if (isVirtual) {
+      inputOptions.input = { index: "#entry" };
+      if (Array.isArray(inputOptions.plugins)) {
+        inputOptions.plugins.unshift(virtual__default.default({ "#entry": serverFile }));
+      } else {
+        inputOptions.plugins = [virtual__default.default({ "#entry": serverFile })];
+      }
+    } else {
+      inputOptions.input = { index: serverFile };
+    }
+    const bundler = await this.createBundler(inputOptions, { dir: bundleLocation });
+    await bundler.write();
+    this.logger.info("Bundling Mastra done");
+    this.logger.info("Installing dependencies");
+    await this.installDependencies(outputDirectory);
+    this.logger.info("Done installing dependencies");
+  }
+};
+
+// src/deploy/base.ts
+var Deployer = class extends Bundler {
+  deps = new Deps();
+  constructor(args) {
+    super(args.name, "DEPLOYER");
+    this.deps.__setLogger(this.logger);
+  }
+  getEnvFiles() {
+    const possibleFiles = [".env.production", ".env"];
+    try {
+      const fileService = new FileService();
+      const envFile = fileService.getFirstExistingFile(possibleFiles);
+      return Promise.resolve([envFile]);
+    } catch {
+    }
+    return Promise.resolve([]);
+  }
+};
+function removeAllExceptDeployer() {
+  let mastraClass = null;
+  const t = babel__namespace.default.types;
+  return {
+    name: "remove-all-except-deployer",
+    visitor: {
+      ExportNamedDeclaration: {
+        // remove all exports
+        exit(path3) {
+          path3.remove();
+        }
+      },
+      ImportDeclaration(path3) {
+        if ((path3.node.source.value === "@mastra/core" || path3.node.source.value === "@mastra/core/mastra") && path3.node.specifiers) {
+          mastraClass = path3.node.specifiers.find(
+            // @ts-ignore - no need to type
+            (p) => p.imported?.name === "Mastra"
+          )?.local?.name ?? null;
+        }
+      },
+      NewExpression(path3) {
+        if (mastraClass && path3.node.callee.name === mastraClass) {
+          const deployer = path3.node.arguments[0]?.properties?.find(
+            // @ts-ignore
+            (prop) => prop.key.name === "deployer"
+          );
+          const programPath = path3.scope.getProgramParent().path;
+          if (!deployer || !programPath) {
+            return;
+          }
+          const exportDeclaration = t.exportNamedDeclaration(
+            t.variableDeclaration("const", [t.variableDeclarator(t.identifier("deployer"), deployer.value)]),
+            []
+          );
+          programPath.node.body.push(exportDeclaration);
+        }
+      }
+    }
+  };
+}
+
+// src/build/deployer.ts
+async function getDeployer(entryFile, outputDir) {
+  const bundle = await rollup.rollup({
+    input: {
+      deployer: entryFile
+    },
+    treeshake: true,
+    plugins: [
+      // transpile typescript to something we understand
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      {
+        name: "get-deployer",
+        transform(code, id) {
+          if (!this.getModuleInfo(id)?.isEntry) {
+            return;
+          }
+          return new Promise((resolve2, reject) => {
+            babel__namespace.transform(
+              code,
+              {
+                babelrc: false,
+                configFile: false,
+                filename: id,
+                plugins: [removeAllExceptDeployer]
+              },
+              (err, result) => {
+                if (err) {
+                  return reject(err);
+                }
+                resolve2({
+                  code: result.code,
+                  map: result.map
+                });
+              }
+            );
+          });
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      })
+    ]
+  });
+  await bundle.write({
+    dir: outputDir,
+    format: "es",
+    entryFileNames: "[name].mjs"
+  });
+  return (await import(`file:${outputDir}/deployer.mjs`)).deployer;
+}
+
+exports.Deployer = Deployer;
+exports.Deps = Deps;
+exports.FileService = FileService;
+exports.createChildProcessLogger = createChildProcessLogger;
+exports.createPinoStream = createPinoStream;
+exports.getDeployer = getDeployer;