@mastra/deployer 0.2.5 → 0.2.6-alpha.10

package/dist/chunk-ZAXXMFXX.js

@@ -1,399 +0,0 @@
-import { spawn } from 'child_process';
-import { Transform } from 'stream';
-import { MastraBase } from '@mastra/core/base';
-import fs from 'fs';
-import path, { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import fsExtra from 'fs-extra/esm';
-import fsPromises from 'fs/promises';
-import * as babel from '@babel/core';
-import babel__default from '@babel/core';
-import { rollup } from 'rollup';
-import esbuild from 'rollup-plugin-esbuild';
-import commonjs from '@rollup/plugin-commonjs';
-
-// src/deploy/log.ts
-var createPinoStream = (logger) => {
-  return new 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 = 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 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.existsSync(path.join(dir, file))) {
-        return file;
-      }
-    }
-    const parentDir = path.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.join(this.rootDir, "package.json");
-      try {
-        await fsPromises.access(packageJsonPath);
-      } catch {
-        return "No package.json file found in the current directory";
-      }
-      const packageJson = JSON.parse(await fsPromises.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.join(this.rootDir, "package.json");
-      const packageJson = await fsPromises.readFile(packageJsonPath, "utf-8");
-      const pkg = JSON.parse(packageJson);
-      return pkg.name;
-    } catch (err) {
-      throw err;
-    }
-  }
-  async getPackageVersion() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const pkgJsonPath = path.join(__dirname, "..", "..", "package.json");
-    const content = await fsExtra.readJSON(pkgJsonPath);
-    return content.version;
-  }
-  async addScriptsToPackageJson(scripts) {
-    const packageJson = JSON.parse(await fsPromises.readFile("package.json", "utf-8"));
-    packageJson.scripts = {
-      ...packageJson.scripts,
-      ...scripts
-    };
-    await fsPromises.writeFile("package.json", JSON.stringify(packageJson, null, 2));
-  }
-};
-function removeAllExceptTelemetryConfig(result) {
-  const t = babel__default.types;
-  return {
-    name: "remove-all-except-telemetry-config",
-    visitor: {
-      ExportNamedDeclaration: {
-        // remove all exports
-        exit(path2) {
-          path2.remove();
-        }
-      },
-      NewExpression(path2, state) {
-        const varDeclaratorPath = path2.findParent((path3) => t.isVariableDeclarator(path3.node));
-        if (!varDeclaratorPath) {
-          return;
-        }
-        const parentNode = path2.parentPath.node;
-        if (!t.isVariableDeclarator(parentNode) || !t.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") {
-          return;
-        }
-        let mastraArgs = t.objectExpression([]);
-        if (t.isObjectExpression(path2.node.arguments[0])) {
-          mastraArgs = path2.node.arguments[0];
-        }
-        let telemetry = mastraArgs.properties.find(
-          // @ts-ignore
-          (prop) => prop.key.name === "telemetry"
-        );
-        let telemetryValue = t.objectExpression([]);
-        const programPath = path2.scope.getProgramParent().path;
-        if (!programPath) {
-          return;
-        }
-        if (telemetry && t.isObjectProperty(telemetry) && t.isExpression(telemetry.value)) {
-          result.hasCustomConfig = true;
-          telemetryValue = telemetry.value;
-          if (t.isIdentifier(telemetry.value) && telemetry.value.name === "telemetry") {
-            const telemetryBinding = state.file.scope.getBinding("telemetry");
-            if (telemetryBinding && t.isVariableDeclarator(telemetryBinding.path.node)) {
-              const id = path2.scope.generateUidIdentifier("telemetry");
-              telemetryBinding.path.replaceWith(t.variableDeclarator(id, telemetryBinding.path.node.init));
-              telemetryValue = id;
-            }
-          }
-        }
-        const exportDeclaration = t.exportNamedDeclaration(
-          t.variableDeclaration("const", [t.variableDeclarator(t.identifier("telemetry"), telemetryValue)]),
-          []
-        );
-        programPath.node.body.push(exportDeclaration);
-      }
-    }
-  };
-}
-function removeNonReferencedNodes() {
-  const t = babel__default.types;
-  return {
-    name: "remove-non-referenced-nodes",
-    visitor: {
-      Program(path2) {
-        const scope = path2.scope;
-        const currentBody = path2.get("body");
-        const filteredBody = currentBody.filter((childPath) => {
-          if (childPath.isExportDeclaration()) {
-            return true;
-          }
-          if (childPath.isVariableDeclaration()) {
-            return childPath.node.declarations.some((decl) => {
-              if (!t.isIdentifier(decl.id)) {
-                return false;
-              }
-              const name = decl.id.name;
-              const binding = scope.getBinding(name);
-              return binding && (binding.referenced || binding.referencePaths.length > 0);
-            });
-          }
-          if (childPath.isFunctionDeclaration() || childPath.isClassDeclaration()) {
-            if (!t.isIdentifier(childPath.node.id)) {
-              return false;
-            }
-            const name = childPath.node.id.name;
-            const binding = scope.getBinding(name);
-            return binding && (binding.referenced || binding.referencePaths.length > 0);
-          }
-          if (childPath.isImportDeclaration()) {
-            return childPath.node.specifiers.some((specifier) => {
-              const importedName = specifier.local.name;
-              const binding = scope.getBinding(importedName);
-              return binding && (binding.referenced || binding.referencePaths.length > 0);
-            });
-          }
-          return false;
-        });
-        path2.set(
-          "body",
-          filteredBody.map((p) => p.node)
-        );
-      }
-    }
-  };
-}
-function recursiveRemoveNonReferencedNodes(code) {
-  return new Promise(async (resolve, reject) => {
-    babel.transform(
-      code,
-      {
-        babelrc: false,
-        configFile: false,
-        plugins: [removeNonReferencedNodes()]
-      },
-      (err, result) => {
-        if (err) {
-          return reject(err);
-        }
-        if (result && result.code !== code) {
-          return recursiveRemoveNonReferencedNodes(result.code).then(resolve, reject);
-        }
-        resolve({
-          code: result.code,
-          map: result.map
-        });
-      }
-    );
-  });
-}
-
-// src/build/telemetry.ts
-function getTelemetryBundler(entryFile, result) {
-  return rollup({
-    logLevel: "silent",
-    input: {
-      "telemetry-config": entryFile
-    },
-    treeshake: "smallest",
-    plugins: [
-      // transpile typescript to something we understand
-      esbuild({
-        target: "node20",
-        platform: "node",
-        minify: false
-      }),
-      commonjs({
-        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.transform(
-              code,
-              {
-                babelrc: false,
-                configFile: false,
-                filename: id,
-                plugins: [removeAllExceptTelemetryConfig(result)]
-              },
-              (err, result2) => {
-                if (err) {
-                  return reject(err);
-                }
-                resolve({
-                  code: result2.code,
-                  map: result2.map
-                });
-              }
-            );
-          });
-        }
-      },
-      // let esbuild remove all unused imports
-      esbuild({
-        target: "node20",
-        platform: "node",
-        minify: false
-      }),
-      {
-        name: "cleanup",
-        transform(code, id) {
-          if (id !== entryFile) {
-            return;
-          }
-          return recursiveRemoveNonReferencedNodes(code);
-        }
-      },
-      // let esbuild remove all unused imports
-      esbuild({
-        target: "node20",
-        platform: "node",
-        minify: false
-      })
-    ]
-  });
-}
-async function writeTelemetryConfig(entryFile, outputDir) {
-  const result = {
-    hasCustomConfig: false
-  };
-  const bundle = await getTelemetryBundler(entryFile, result);
-  await bundle.write({
-    dir: outputDir,
-    format: "es",
-    entryFileNames: "[name].mjs"
-  });
-  return result;
-}
-
-export { Deps, createChildProcessLogger, createPinoStream, recursiveRemoveNonReferencedNodes, writeTelemetryConfig };