@mastra/deployer 0.2.5 → 0.2.6-alpha.10

package/dist/{chunk-OT6UKL2S.cjs → chunk-AE4CVAPK.cjs}

@@ -74,6 +74,17 @@ async function getInputOptions(entryFile, analyzedBundleInfo, platform) {
             find: /^\#server$/,
             replacement: url.fileURLToPath(undefined("@mastra/deployer/server")).replaceAll("\\", "/")
           },
+          {
+            find: /^\@mastra\/server\/(.*)/,
+            replacement: `@mastra/server/$1`,
+            customResolver: (id) => {
+              if (id.startsWith("@mastra/server")) {
+                return {
+                  id: url.fileURLToPath(undefined(id))
+                };
+              }
+            }
+          },
           { find: /^\#mastra$/, replacement: normalizedEntryFile }
         ]
       }),

package/dist/{chunk-UTZ3434D.js → chunk-BDTZS3JM.js}

@@ -115,6 +115,9 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger) {
           if (id === "#mastra") {
             return normalizedMastraEntry;
           }
+          if (id.startsWith("@mastra/server")) {
+            return fileURLToPath(import.meta.resolve(id));
+          }
         }
       },
       json(),

package/dist/chunk-DYQ225MJ.js

@@ -0,0 +1,115 @@
+import * as fs2 from 'fs';
+import fs2__default from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fsExtra from 'fs-extra/esm';
+
+// src/services/env.ts
+var EnvService = class {
+};
+var FileEnvService = class extends EnvService {
+  filePath;
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
+  }
+  readFile(filePath) {
+    return new Promise((resolve, reject) => {
+      fs2.readFile(filePath, "utf8", (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
+  }
+  writeFile({ filePath, data }) {
+    return new Promise((resolve, reject) => {
+      fs2.writeFile(filePath, data, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  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}`);
+    }
+  }
+};
+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 = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const filePath = path.resolve(__dirname, "..", "starter-files", inputFile);
+    const fileString = fs2__default.readFileSync(filePath, "utf8");
+    if (fs2__default.existsSync(outputFilePath) && !replaceIfExists) {
+      console.log(`${outputFilePath} already exists`);
+      return false;
+    }
+    await fsExtra.outputFile(outputFilePath, fileString);
+    return true;
+  }
+  async setupEnvFile({ dbUrl }) {
+    const envPath = path.join(process.cwd(), ".env.development");
+    await fsExtra.ensureFile(envPath);
+    const fileEnvService = new FileEnvService(envPath);
+    await fileEnvService.setEnvValue("DB_URL", dbUrl);
+  }
+  getFirstExistingFile(files) {
+    for (const f of files) {
+      if (fs2__default.existsSync(f)) {
+        return f;
+      }
+    }
+    throw new Error("Missing required file, checked the following paths: " + files.join(", "));
+  }
+  replaceValuesInFile({
+    filePath,
+    replacements
+  }) {
+    let fileContent = fs2__default.readFileSync(filePath, "utf8");
+    replacements.forEach(({ search, replace }) => {
+      fileContent = fileContent.replaceAll(search, replace);
+    });
+    fs2__default.writeFileSync(filePath, fileContent);
+  }
+};
+
+export { EnvService, FileService };

package/dist/chunk-I3UVE6EH.cjs

@@ -0,0 +1,161 @@
+'use strict';
+
+var chunk2ZPQX6BX_cjs = require('./chunk-2ZPQX6BX.cjs');
+var chunkP5SATU7G_cjs = require('./chunk-P5SATU7G.cjs');
+var chunkAE4CVAPK_cjs = require('./chunk-AE4CVAPK.cjs');
+var rollup = require('rollup');
+var babel = require('@babel/core');
+var esbuild = require('rollup-plugin-esbuild');
+var commonjs = require('@rollup/plugin-commonjs');
+
+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 babel__namespace = /*#__PURE__*/_interopNamespace(babel);
+var esbuild__default = /*#__PURE__*/_interopDefault(esbuild);
+var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
+
+async function getInputOptions2(entryFile, platform) {
+  const inputOptions = await chunkAE4CVAPK_cjs.getInputOptions(
+    entryFile,
+    {
+      dependencies: /* @__PURE__ */ new Map(),
+      externalDependencies: /* @__PURE__ */ new Set(),
+      invalidChunks: /* @__PURE__ */ new Set()
+    },
+    platform
+  );
+  if (Array.isArray(inputOptions.plugins)) {
+    inputOptions.plugins = inputOptions.plugins.filter(
+      // @ts-ignore
+      (plugin) => !plugin || !plugin?.name || plugin.name !== "node-resolve"
+    );
+    inputOptions.plugins.push(chunkP5SATU7G_cjs.aliasHono());
+  }
+  return inputOptions;
+}
+async function createWatcher(inputOptions, outputOptions) {
+  const watcher = await rollup.watch({
+    ...inputOptions,
+    output: {
+      ...outputOptions,
+      format: "esm",
+      entryFileNames: "[name].mjs",
+      chunkFileNames: "[name].mjs"
+    }
+  });
+  return watcher;
+}
+
+// src/build/babel/remove-all-options-server.ts
+function removeAllOptionsExceptServer(result) {
+  return chunk2ZPQX6BX_cjs.removeAllOptionsFromMastraExcept(result, "server");
+}
+function getServerOptionsBundler(entryFile, result) {
+  return rollup.rollup({
+    logLevel: "silent",
+    input: {
+      "server-config": entryFile
+    },
+    treeshake: "smallest",
+    plugins: [
+      // transpile typescript to something we understand
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      commonjs__default.default({
+        extensions: [".js", ".ts"],
+        strictRequires: "strict",
+        transformMixedEsModules: true,
+        ignoreTryCatch: false
+      }),
+      {
+        name: "get-server-config",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return new Promise((resolve, reject) => {
+            babel__namespace.transform(
+              code,
+              {
+                babelrc: false,
+                configFile: false,
+                filename: id,
+                plugins: [removeAllOptionsExceptServer(result)]
+              },
+              (err, result2) => {
+                if (err) {
+                  return reject(err);
+                }
+                resolve({
+                  code: result2.code,
+                  map: result2.map
+                });
+              }
+            );
+          });
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      {
+        name: "cleanup",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return chunk2ZPQX6BX_cjs.recursiveRemoveNonReferencedNodes(code);
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      })
+    ]
+  });
+}
+async function getServerOptions(entryFile, outputDir) {
+  const result = {
+    hasCustomConfig: false
+  };
+  const bundle = await getServerOptionsBundler(entryFile, result);
+  await bundle.write({
+    dir: outputDir,
+    format: "es",
+    entryFileNames: "[name].mjs"
+  });
+  if (result.hasCustomConfig) {
+    return (await import(`file:${outputDir}/server-config.mjs`)).server;
+  }
+  return null;
+}
+
+exports.createWatcher = createWatcher;
+exports.getInputOptions = getInputOptions2;
+exports.getServerOptions = getServerOptions;

package/dist/{chunk-XEFBJH3T.js → chunk-IKPL4RGG.js}

@@ -64,6 +64,17 @@ async function getInputOptions(entryFile, analyzedBundleInfo, platform) {
             find: /^\#server$/,
             replacement: fileURLToPath(import.meta.resolve("@mastra/deployer/server")).replaceAll("\\", "/")
           },
+          {
+            find: /^\@mastra\/server\/(.*)/,
+            replacement: `@mastra/server/$1`,
+            customResolver: (id) => {
+              if (id.startsWith("@mastra/server")) {
+                return {
+                  id: fileURLToPath(import.meta.resolve(id))
+                };
+              }
+            }
+          },
           { find: /^\#mastra$/, replacement: normalizedEntryFile }
         ]
       }),

package/dist/chunk-NCROGJGB.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+var fs2 = require('fs');
+var path = require('path');
+var url = require('url');
+var fsExtra = require('fs-extra/esm');
+
+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 fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fsExtra__default = /*#__PURE__*/_interopDefault(fsExtra);
+
+// src/services/env.ts
+var EnvService = class {
+};
+var FileEnvService = class extends EnvService {
+  filePath;
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
+  }
+  readFile(filePath) {
+    return new Promise((resolve, reject) => {
+      fs2__namespace.readFile(filePath, "utf8", (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
+  }
+  writeFile({ filePath, data }) {
+    return new Promise((resolve, reject) => {
+      fs2__namespace.writeFile(filePath, data, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  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}`);
+    }
+  }
+};
+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('chunk-NCROGJGB.cjs', document.baseURI).href)));
+    const __dirname = path__default.default.dirname(__filename);
+    const filePath = path__default.default.resolve(__dirname, "..", "starter-files", inputFile);
+    const fileString = fs2__namespace.default.readFileSync(filePath, "utf8");
+    if (fs2__namespace.default.existsSync(outputFilePath) && !replaceIfExists) {
+      console.log(`${outputFilePath} already exists`);
+      return false;
+    }
+    await fsExtra__default.default.outputFile(outputFilePath, fileString);
+    return true;
+  }
+  async setupEnvFile({ dbUrl }) {
+    const envPath = path__default.default.join(process.cwd(), ".env.development");
+    await fsExtra__default.default.ensureFile(envPath);
+    const fileEnvService = new FileEnvService(envPath);
+    await fileEnvService.setEnvValue("DB_URL", dbUrl);
+  }
+  getFirstExistingFile(files) {
+    for (const f of files) {
+      if (fs2__namespace.default.existsSync(f)) {
+        return f;
+      }
+    }
+    throw new Error("Missing required file, checked the following paths: " + files.join(", "));
+  }
+  replaceValuesInFile({
+    filePath,
+    replacements
+  }) {
+    let fileContent = fs2__namespace.default.readFileSync(filePath, "utf8");
+    replacements.forEach(({ search, replace }) => {
+      fileContent = fileContent.replaceAll(search, replace);
+    });
+    fs2__namespace.default.writeFileSync(filePath, fileContent);
+  }
+};
+
+exports.EnvService = EnvService;
+exports.FileService = FileService;

package/dist/{chunk-NWERLYTR.cjs → chunk-P5SATU7G.cjs}

@@ -125,6 +125,9 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger) {
           if (id === "#mastra") {
             return normalizedMastraEntry;
           }
+          if (id.startsWith("@mastra/server")) {
+            return url.fileURLToPath(undefined(id));
+          }
         }
       },
       json__default.default(),

package/dist/chunk-VFZVVUQE.cjs

@@ -0,0 +1,198 @@
+'use strict';
+
+var child_process = require('child_process');
+var stream = require('stream');
+var fs = require('fs');
+var fsPromises = require('fs/promises');
+var path = require('path');
+var url = require('url');
+var base = require('@mastra/core/base');
+var fsExtra = require('fs-extra/esm');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var fsPromises__default = /*#__PURE__*/_interopDefault(fsPromises);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fsExtra__default = /*#__PURE__*/_interopDefault(fsExtra);
+
+// src/deploy/log.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((resolve, reject) => {
+        subprocess.on("close", (code) => {
+          pinoStream.end();
+          if (code === 0) {
+            resolve({ 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 };
+    }
+  };
+}
+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 (fs__default.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;
+    switch (this.packageManager) {
+      case "npm":
+        runCommand = `${this.packageManager} i`;
+        break;
+      case "pnpm":
+        runCommand = `${this.packageManager} --ignore-workspace install`;
+        break;
+      default:
+        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('chunk-VFZVVUQE.cjs', document.baseURI).href)));
+    const __dirname = path.dirname(__filename);
+    const pkgJsonPath = path__default.default.join(__dirname, "..", "..", "package.json");
+    const content = await fsExtra__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 DepsService = class extends Deps {
+};
+
+exports.Deps = Deps;
+exports.DepsService = DepsService;
+exports.createChildProcessLogger = createChildProcessLogger;
+exports.createPinoStream = createPinoStream;