@mastra/deployer 0.10.13 → 0.10.15-alpha.0

package/dist/chunk-KCP5ITLV.cjs

@@ -0,0 +1,412 @@
+'use strict';
+
+var child_process = require('child_process');
+var stream = require('stream');
+var fs3 = 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 }; }
+
+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 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 (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";
+    }
+  }
+  getWorkspaceDependencyPath({ pkgName, version }) {
+    return `file:./workspace-module/${pkgName}-${version}.tgz`;
+  }
+  async pack({ dir, destination }) {
+    const cpLogger = createChildProcessLogger({
+      logger: this.logger,
+      root: dir
+    });
+    return cpLogger({
+      cmd: `${this.packageManager} pack --pack-destination ${destination}`,
+      args: [],
+      env: {
+        PATH: process.env.PATH
+      }
+    });
+  }
+  async writePnpmConfig(dir, options) {
+    const packageJsonPath = path__default.default.join(dir, "package.json");
+    const packageJson = await fsExtra.readJSON(packageJsonPath);
+    packageJson.pnpm = {
+      ...packageJson.pnpm,
+      supportedArchitectures: {
+        os: options.os || [],
+        cpu: options.cpu || [],
+        libc: options.libc || []
+      }
+    };
+    await fsExtra.writeJSON(packageJsonPath, packageJson, { spaces: 2 });
+  }
+  async writeYarnConfig(dir, options) {
+    const yarnrcPath = path__default.default.join(dir, ".yarnrc.yml");
+    const config = {
+      supportedArchitectures: {
+        cpu: options.cpu || [],
+        os: options.os || [],
+        libc: options.libc || []
+      }
+    };
+    await fsPromises__default.default.writeFile(
+      yarnrcPath,
+      `supportedArchitectures:
+${Object.entries(config.supportedArchitectures).map(([key, value]) => `  ${key}: ${JSON.stringify(value)}`).join("\n")}`
+    );
+  }
+  getNpmArgs(options) {
+    const args = [];
+    if (options.cpu) args.push(`--cpu=${options.cpu.join(",")}`);
+    if (options.os) args.push(`--os=${options.os.join(",")}`);
+    if (options.libc) args.push(`--libc=${options.libc.join(",")}`);
+    return args;
+  }
+  async install({
+    dir = this.rootDir,
+    architecture
+  } = {}) {
+    let runCommand = this.packageManager;
+    let args = [];
+    switch (this.packageManager) {
+      case "pnpm":
+        runCommand = `${this.packageManager} --ignore-workspace install`;
+        if (architecture) {
+          await this.writePnpmConfig(dir, architecture);
+        }
+        break;
+      case "yarn":
+        await fsExtra.ensureFile(path__default.default.join(dir, "yarn.lock"));
+        if (architecture) {
+          await this.writeYarnConfig(dir, architecture);
+        }
+        runCommand = `${this.packageManager} install`;
+        break;
+      case "npm":
+        runCommand = `${this.packageManager} install`;
+        if (architecture) {
+          args = this.getNpmArgs(architecture);
+        }
+        break;
+      default:
+        runCommand = `${this.packageManager} install`;
+    }
+    const cpLogger = createChildProcessLogger({
+      logger: this.logger,
+      root: dir
+    });
+    const env = {
+      PATH: process.env.PATH
+    };
+    if (process.env.npm_config_registry) {
+      env.npm_config_registry = process.env.npm_config_registry;
+    }
+    return cpLogger({
+      cmd: runCommand,
+      args,
+      env
+    });
+  }
+  async installPackages(packages) {
+    let runCommand = this.packageManager;
+    if (this.packageManager === "npm") {
+      runCommand = `${this.packageManager} i`;
+    } else {
+      runCommand = `${this.packageManager} add`;
+    }
+    const env = {
+      PATH: process.env.PATH
+    };
+    if (process.env.npm_config_registry) {
+      env.npm_config_registry = process.env.npm_config_registry;
+    }
+    const cpLogger = createChildProcessLogger({
+      logger: this.logger,
+      root: ""
+    });
+    return cpLogger({
+      cmd: `${runCommand}`,
+      args: packages,
+      env
+    });
+  }
+  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 = await fsExtra.readJSON(packageJsonPath);
+      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 pkg = await fsExtra.readJSON(packageJsonPath);
+      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-KCP5ITLV.cjs', document.baseURI).href)));
+    const __dirname = path.dirname(__filename);
+    const pkgJsonPath = path__default.default.join(__dirname, "..", "..", "package.json");
+    const content = await fsExtra.readJSON(pkgJsonPath);
+    return content.version;
+  }
+  async addScriptsToPackageJson(scripts) {
+    const packageJson = await fsExtra.readJSON("package.json");
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      ...scripts
+    };
+    await fsExtra.writeJSON("package.json", packageJson, { spaces: 2 });
+  }
+};
+var DepsService = class extends Deps {
+};
+var EnvService = class {
+};
+var FileEnvService = class extends EnvService {
+  filePath;
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
+  }
+  readFile(filePath) {
+    return new Promise((resolve, reject) => {
+      fs3__namespace.readFile(filePath, "utf8", (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
+  }
+  writeFile({ filePath, data }) {
+    return new Promise((resolve, reject) => {
+      fs3__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-KCP5ITLV.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 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 (fs3__namespace.default.existsSync(f)) {
+        return f;
+      }
+    }
+    throw new Error("Missing required file, checked the following paths: " + files.join(", "));
+  }
+  /**
+   * Returns the first existing file from the provided array, or undefined if none exist
+   * @param files array of file paths to check
+   * @returns the first existing file path or undefined
+   */
+  getFirstExistingFileOrUndefined(files) {
+    for (const f of files) {
+      if (fs3__namespace.default.existsSync(f)) {
+        return f;
+      }
+    }
+    return void 0;
+  }
+  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);
+  }
+};
+
+exports.Deps = Deps;
+exports.DepsService = DepsService;
+exports.EnvService = EnvService;
+exports.FileService = FileService;
+exports.createChildProcessLogger = createChildProcessLogger;
+exports.createPinoStream = createPinoStream;

package/dist/chunk-M2VZQFTW.cjs

@@ -0,0 +1,125 @@
+'use strict';
+
+var chunkXKH6F4NE_cjs = require('./chunk-XKH6F4NE.cjs');
+var babel = require('@babel/core');
+var rollup = require('rollup');
+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);
+
+// src/build/babel/remove-all-options-telemetry.ts
+function removeAllOptionsExceptTelemetry(result) {
+  return chunkXKH6F4NE_cjs.removeAllOptionsFromMastraExcept(result, "telemetry");
+}
+
+// src/build/telemetry.ts
+function getTelemetryBundler(entryFile, result) {
+  return rollup.rollup({
+    logLevel: "silent",
+    input: {
+      "telemetry-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-telemetry-config",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return new Promise((resolve, reject) => {
+            babel__namespace.transform(
+              code,
+              {
+                babelrc: false,
+                configFile: false,
+                filename: id,
+                plugins: [removeAllOptionsExceptTelemetry(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 chunkXKH6F4NE_cjs.recursiveRemoveNonReferencedNodes(code);
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      })
+    ]
+  });
+}
+async function writeTelemetryConfig(entryFile, outputDir) {
+  const result = {
+    hasCustomConfig: false
+  };
+  const bundle = await getTelemetryBundler(entryFile, result);
+  const { output } = await bundle.write({
+    dir: outputDir,
+    format: "es",
+    entryFileNames: "[name].mjs"
+  });
+  const externals = output[0].imports.filter((x) => !x.startsWith("./"));
+  return { ...result, externalDependencies: externals };
+}
+
+exports.writeTelemetryConfig = writeTelemetryConfig;

package/dist/chunk-TIC2KT3M.js

@@ -0,0 +1,146 @@
+import { tsConfigPaths, removeDeployer } from './chunk-Z544XXXK.js';
+import alias from '@rollup/plugin-alias';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import { fileURLToPath } from 'url';
+import { rollup } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+
+async function getInputOptions(entryFile, analyzedBundleInfo, platform, env = { "process.env.NODE_ENV": JSON.stringify("production") }) {
+  let nodeResolvePlugin = platform === "node" ? nodeResolve({
+    preferBuiltins: true,
+    exportConditions: ["node"]
+  }) : nodeResolve({
+    preferBuiltins: false,
+    browser: true
+  });
+  const externalsCopy = /* @__PURE__ */ new Set();
+  for (const external of analyzedBundleInfo.externalDependencies) {
+    if (external.startsWith("@")) {
+      const [scope, name] = external.split("/", 3);
+      externalsCopy.add(`${scope}/${name}`);
+      externalsCopy.add(`${scope}/${name}/*`);
+    } else {
+      externalsCopy.add(external);
+      externalsCopy.add(`${external}/*`);
+    }
+  }
+  const externals = Array.from(externalsCopy);
+  const normalizedEntryFile = entryFile.replaceAll("\\", "/");
+  return {
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    treeshake: "smallest",
+    preserveSymlinks: true,
+    external: externals,
+    plugins: [
+      tsConfigPaths(),
+      {
+        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({
+        entries: [
+          {
+            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 }
+        ]
+      }),
+      {
+        name: "tools-rewriter",
+        resolveId(id) {
+          if (id === "#tools") {
+            return {
+              id: "./tools.mjs",
+              external: true
+            };
+          }
+        }
+      },
+      esbuild({
+        target: "node20",
+        platform,
+        minify: false,
+        define: env
+      }),
+      commonjs({
+        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(),
+      removeDeployer(entryFile),
+      // treeshake unused imports
+      esbuild({
+        include: entryFile,
+        target: "node20",
+        platform,
+        minify: false
+      })
+    ].filter(Boolean)
+  };
+}
+async function createBundler(inputOptions, outputOptions) {
+  const bundler = await rollup(inputOptions);
+  return {
+    write: () => {
+      return bundler.write({
+        ...outputOptions,
+        format: "esm",
+        entryFileNames: "[name].mjs",
+        chunkFileNames: "[name].mjs"
+      });
+    },
+    close: () => {
+      return bundler.close();
+    }
+  };
+}
+
+export { createBundler, getInputOptions };