@mastra/deployer 0.0.0-storage-20250225005900

package/dist/chunk-AXS5WSIK.js

@@ -0,0 +1,290 @@
+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';
+
+// 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;
+    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.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) {
+  let mastraClass = null;
+  const t = babel__default.types;
+  return {
+    name: "remove-all-except-telemetry-config",
+    visitor: {
+      ExportNamedDeclaration: {
+        // remove all exports
+        exit(path2) {
+          path2.remove();
+        }
+      },
+      ImportDeclaration(path2) {
+        if ((path2.node.source.value === "@mastra/core" || path2.node.source.value === "@mastra/core/mastra") && path2.node.specifiers) {
+          mastraClass = path2.node.specifiers.find(
+            // @ts-ignore - no need to type
+            (p) => p.imported?.name === "Mastra"
+          )?.local?.name ?? null;
+        }
+      },
+      NewExpression(path2) {
+        if (mastraClass && path2.node.callee.name === mastraClass) {
+          let telemetry = path2.node.arguments[0]?.properties?.find(
+            // @ts-ignore
+            (prop) => prop.key.name === "telemetry"
+          );
+          const programPath = path2.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({
+    input: {
+      "telemetry-config": entryFile
+    },
+    treeshake: true,
+    plugins: [
+      // transpile typescript to something we understand
+      esbuild({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      {
+        name: "get-telemetry-config",
+        transform(code, id) {
+          if (!this.getModuleInfo(id)?.isEntry) {
+            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
+      })
+    ]
+  });
+  await bundle.write({
+    dir: outputDir,
+    format: "es",
+    entryFileNames: "[name].mjs"
+  });
+  return result;
+}
+
+export { Deps, createChildProcessLogger, createPinoStream, writeTelemetryConfig };

package/dist/chunk-BTUQ6UBB.js

@@ -0,0 +1,254 @@
+import { aliasHono } from './chunk-SESHBX76.js';
+import { getInputOptions, telemetryFix, libSqlFix } from './chunk-KXS4XYEJ.js';
+import { removeDeployer } from './chunk-YNXJO2XU.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 { builtinModules } from 'node:module';
+import path, { join } from 'path';
+import { rollup, watch } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+import { fileURLToPath } from 'url';
+import * as fs2 from 'fs';
+import fs2__default from 'fs';
+import fsExtra from 'fs-extra/esm';
+
+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}`);
+    }
+  }
+};
+
+// 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 = 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);
+  }
+};
+
+// src/build/bundle.ts
+function getOptions(inputOptions, platform, root) {
+  const fileService = new FileService();
+  const entry = fileService.getFirstExistingFile([
+    join(root, "src/mastra/index.ts"),
+    join(root, "src/mastra/index.js")
+  ]);
+  const nodeBuiltins = platform === "node" ? builtinModules : [];
+  let nodeResolvePlugin = platform === "node" ? nodeResolve({
+    preferBuiltins: true,
+    exportConditions: ["node", "import", "require"],
+    mainFields: ["module", "main"]
+  }) : nodeResolve({
+    preferBuiltins: false,
+    exportConditions: ["browser", "import", "require"],
+    mainFields: ["module", "main"],
+    browser: true
+  });
+  return {
+    logLevel: "silent",
+    ...inputOptions,
+    treeshake: false,
+    preserveSymlinks: true,
+    external: [
+      ...nodeBuiltins,
+      ...nodeBuiltins.map((builtin) => "node:" + builtin),
+      ...inputOptions.external ?? []
+    ],
+    plugins: [
+      ...inputOptions.plugins ?? [],
+      telemetryFix(),
+      alias({
+        entries: [
+          {
+            find: /^\#server$/,
+            replacement: fileURLToPath(import.meta.resolve("@mastra/deployer/server")).replaceAll("\\", "/")
+          },
+          { find: /^\#mastra$/, replacement: entry.replaceAll("\\", "/") },
+          {
+            find: /^hono\//,
+            replacement: "hono/",
+            customResolver: (id, importer) => {
+              if (!importer?.startsWith("\0virtual")) {
+                return null;
+              }
+              const path2 = import.meta.resolve(id);
+              return fileURLToPath(path2);
+            }
+          }
+        ]
+      }),
+      commonjs({
+        strictRequires: "strict",
+        transformMixedEsModules: true
+        // dynamicRequireTargets: ['node_modules/**/@libsql+win32-*/*'],
+      }),
+      libSqlFix(),
+      // for debugging
+      // {
+      //   name: 'logger',
+      //   // @ts-ignore
+      //   resolveId(id, ...args) {
+      //     console.log({ id, args });
+      //   },
+      // },
+      nodeResolvePlugin,
+      json(),
+      esbuild({
+        include: /\.tsx?$/,
+        target: "node20",
+        platform,
+        minify: false,
+        define: {
+          "process.env.NODE_ENV": JSON.stringify("production")
+        }
+      }),
+      removeDeployer(entry),
+      esbuild({
+        include: entry,
+        target: "node20",
+        platform,
+        minify: false
+      })
+    ].filter(Boolean)
+  };
+}
+async function getBundler(inputOptions, args = {}) {
+  const { platform = "node", dir = process.cwd() } = args;
+  const bundle = await rollup(getOptions(inputOptions, platform, dir));
+  return bundle;
+}
+async function getWatcher(inputOptions, args = {}) {
+  const { platform = "node", dir = process.cwd() } = args;
+  const watcher = watch(getOptions(inputOptions, platform, dir));
+  return watcher;
+}
+async function getInputOptions2(entryFile, platform) {
+  const inputOptions = await 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(aliasHono());
+  }
+  return inputOptions;
+}
+async function createWatcher(inputOptions, outputOptions) {
+  const watcher = await watch({
+    ...inputOptions,
+    output: {
+      ...outputOptions,
+      format: "esm",
+      entryFileNames: "[name].mjs",
+      chunkFileNames: "[name].mjs"
+    }
+  });
+  return watcher;
+}
+
+export { FileService, createWatcher, getBundler, getInputOptions2 as getInputOptions, getWatcher };

package/dist/chunk-IHPQAB7O.js

@@ -0,0 +1,113 @@
+import { Deps, writeTelemetryConfig } from './chunk-AXS5WSIK.js';
+import { analyzeBundle } from './chunk-SESHBX76.js';
+import { createBundler, getInputOptions } from './chunk-KXS4XYEJ.js';
+import { MastraBundler } from '@mastra/core/bundler';
+import virtual from '@rollup/plugin-virtual';
+import { ensureDir, copy } from 'fs-extra';
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fsExtra from 'fs-extra/esm';
+
+var Bundler = class extends MastraBundler {
+  analyzeOutputDir = ".build";
+  outputDir = "output";
+  constructor(name, component = "BUNDLER") {
+    super({ name, component });
+  }
+  async prepare(outputDirectory) {
+    await fsExtra.emptyDir(outputDirectory);
+    await ensureDir(join(outputDirectory, this.analyzeOutputDir));
+    await ensureDir(join(outputDirectory, this.outputDir));
+  }
+  async writeInstrumentationFile(outputDirectory) {
+    const instrumentationFile = join(outputDirectory, "instrumentation.mjs");
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    await copy(join(__dirname, "templates", "instrumentation-template.js"), instrumentationFile);
+  }
+  async writePackageJson(outputDirectory, dependencies) {
+    this.logger.debug(`Writing project's package.json`);
+    await ensureDir(outputDirectory);
+    const pkgPath = 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 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, 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: join(outputDirectory, this.outputDir) });
+  }
+  async _bundle(serverFile, mastraEntryFile, outputDirectory, bundleLocation = join(outputDirectory, this.outputDir)) {
+    this.logger.info("Start bundling Mastra");
+    const isVirtual = serverFile.includes("\n") || existsSync(serverFile);
+    const analyzedBundleInfo = await analyzeBundle(
+      serverFile,
+      mastraEntryFile,
+      join(outputDirectory, this.analyzeOutputDir),
+      "node",
+      this.logger
+    );
+    await writeTelemetryConfig(mastraEntryFile, 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(join(outputDirectory, this.outputDir), dependenciesToInstall);
+    await this.writeInstrumentationFile(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({ "#entry": serverFile }));
+      } else {
+        inputOptions.plugins = [virtual({ "#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");
+  }
+};
+
+export { Bundler };