@mastra/deployer 0.0.0-commonjs-20250227130920

package/src/build/babel/get-telemetry-config.ts

@@ -0,0 +1,62 @@
+import babel from '@babel/core';
+
+export function removeAllExceptTelemetryConfig(result: { hasCustomConfig: boolean }) {
+  let mastraClass: string | null = null;
+
+  const t = babel.types;
+
+  return {
+    name: 'remove-all-except-telemetry-config',
+    visitor: {
+      ExportNamedDeclaration: {
+        // remove all exports
+        exit(path) {
+          path.remove();
+        },
+      },
+      ImportDeclaration(path) {
+        if (
+          (path.node.source.value === '@mastra/core' || path.node.source.value === '@mastra/core/mastra') &&
+          path.node.specifiers
+        ) {
+          mastraClass =
+            path.node.specifiers.find(
+              // @ts-ignore - no need to type
+              p => p.imported?.name === 'Mastra',
+            )?.local?.name ?? null;
+        }
+      },
+      NewExpression(path) {
+        if (mastraClass && (path.node.callee as babel.types.Identifier).name === mastraClass) {
+          // @ts-ignore
+          let telemetry = path.node.arguments[0]?.properties?.find(
+            // @ts-ignore
+            prop => prop.key.name === 'telemetry',
+          );
+
+          const programPath = path.scope.getProgramParent().path;
+          if (!programPath) {
+            return;
+          }
+
+          if (telemetry) {
+            result.hasCustomConfig = true;
+          } else {
+            telemetry = {
+              value: t.objectExpression([]),
+            };
+          }
+
+          // add the deployer export
+          const exportDeclaration = t.exportNamedDeclaration(
+            t.variableDeclaration('const', [t.variableDeclarator(t.identifier('telemetry'), telemetry.value)]),
+            [],
+          );
+
+          // @ts-ignore
+          programPath.node.body.push(exportDeclaration);
+        }
+      },
+    },
+  } as babel.PluginObj;
+}

package/src/build/babel/remove-deployer.ts

@@ -0,0 +1,43 @@
+import babel from '@babel/core';
+
+export function removeDeployer() {
+  const t = babel.types;
+  let mastraClass: string | null = null;
+
+  return {
+    name: 'remove-deployer',
+    visitor: {
+      ImportDeclaration(path) {
+        if (
+          (path.node.source.value === '@mastra/core' || path.node.source.value === '@mastra/core/mastra') &&
+          path.node.specifiers
+        ) {
+          const mastraObj = path.node.specifiers.find(
+            p => t.isImportSpecifier(p) && t.isIdentifier(p.imported) && p.imported.name === 'Mastra',
+          );
+
+          if (mastraObj?.local?.name) {
+            mastraClass = mastraObj.local.name;
+          }
+        }
+      },
+      NewExpression(path, state) {
+        if (
+          mastraClass &&
+          t.isIdentifier(path.node.callee) &&
+          path.node.callee.name === mastraClass &&
+          !state.hasReplaced
+        ) {
+          state.hasReplaced = true;
+          const newMastraObj = t.cloneNode(path.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',
+            );
+            path.replaceWith(newMastraObj);
+          }
+        }
+      },
+    },
+  } as babel.PluginObj;
+}

package/src/build/bundle.ts

@@ -0,0 +1,139 @@
+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 { join } from 'path';
+import { rollup, watch, type InputOptions, type Plugin, type InputOption } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+import { fileURLToPath } from 'url';
+
+import { FileService } from './fs';
+import { libSqlFix } from './plugins/fix-libsql';
+import { removeDeployer } from './plugins/remove-deployer';
+import { telemetryFix } from './plugins/telemetry-fix';
+
+type NormalizedInputOptions = Omit<Partial<InputOptions>, 'plugins' | 'input' | 'external'> & {
+  plugins?: Plugin[];
+  input: InputOption;
+  external?: (string | RegExp)[];
+};
+
+function getOptions(inputOptions: NormalizedInputOptions, platform: 'node' | 'browser', root: string): InputOptions {
+  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: string) => '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: string, importer: string | undefined) => {
+              if (!importer?.startsWith('\x00virtual')) {
+                return null;
+              }
+
+              const path = import.meta.resolve(id);
+              return fileURLToPath(path);
+            },
+          },
+        ],
+      }),
+      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),
+  };
+}
+
+export async function getBundler(
+  inputOptions: NormalizedInputOptions,
+  args: {
+    platform?: 'node' | 'browser';
+    dir?: string;
+  } = {},
+) {
+  const { platform = 'node', dir = process.cwd() } = args;
+  const bundle = await rollup(getOptions(inputOptions, platform, dir));
+
+  return bundle;
+}
+
+export async function getWatcher(
+  inputOptions: NormalizedInputOptions,
+  args: {
+    platform?: 'node' | 'browser';
+    dir?: string;
+  } = {},
+) {
+  const { platform = 'node', dir = process.cwd() } = args;
+  const watcher = watch(getOptions(inputOptions, platform, dir));
+
+  return watcher;
+}

package/src/build/bundler.ts

@@ -0,0 +1,135 @@
+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 'node:url';
+import { rollup, type InputOptions, type OutputOptions } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+
+import type { analyzeBundle } from './analyze';
+import { libSqlFix } from './plugins/fix-libsql';
+import { removeDeployer } from './plugins/remove-deployer';
+import { telemetryFix } from './plugins/telemetry-fix';
+
+export async function getInputOptions(
+  entryFile: string,
+  analyzedBundleInfo: Awaited<ReturnType<typeof analyzeBundle>>,
+  platform: 'node' | 'browser',
+): Promise<InputOptions> {
+  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,
+        });
+
+  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({
+        entries: [
+          {
+            find: /^\#server$/,
+            replacement: fileURLToPath(import.meta.resolve('@mastra/deployer/server')).replaceAll('\\', '/'),
+          },
+          { find: /^\#mastra$/, replacement: entryFile.replaceAll('\\', '/') },
+        ],
+      }),
+      esbuild({
+        target: 'node20',
+        platform,
+        minify: false,
+        define: {
+          'process.env.NODE_ENV': JSON.stringify('production'),
+        },
+      }),
+      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),
+  } satisfies InputOptions;
+}
+
+export async function createBundler(
+  inputOptions: InputOptions,
+  outputOptions: Partial<OutputOptions> & { dir: string },
+) {
+  const bundler = await rollup(inputOptions);
+
+  return {
+    write: () => {
+      return bundler.write({
+        ...outputOptions,
+        format: 'esm',
+        entryFileNames: '[name].mjs',
+        chunkFileNames: '[name].mjs',
+      });
+    },
+    close: () => {
+      return bundler.close();
+    },
+  };
+}

package/src/build/deployer.ts

@@ -0,0 +1,67 @@
+import * as babel from '@babel/core';
+import type { MastraDeployer } from '@mastra/core';
+import { rollup } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+
+import { removeAllExceptDeployer } from './babel/get-deployer';
+
+export async function getDeployer(entryFile: string, outputDir: string) {
+  const bundle = await rollup({
+    input: {
+      deployer: entryFile,
+    },
+    treeshake: true,
+    plugins: [
+      // transpile typescript to something we understand
+      esbuild({
+        target: 'node20',
+        platform: 'node',
+        minify: false,
+      }),
+      {
+        name: 'get-deployer',
+        transform(code, id) {
+          if (!this.getModuleInfo(id)?.isEntry) {
+            return;
+          }
+
+          return new Promise((resolve, reject) => {
+            babel.transform(
+              code,
+              {
+                babelrc: false,
+                configFile: false,
+                filename: id,
+                plugins: [removeAllExceptDeployer],
+              },
+              (err, result) => {
+                if (err) {
+                  return reject(err);
+                }
+
+                resolve({
+                  code: result!.code!,
+                  map: result!.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 (await import(`file:${outputDir}/deployer.mjs`)).deployer as unknown as MastraDeployer;
+}

package/src/build/deps.ts

@@ -0,0 +1,149 @@
+import { MastraBase } from '@mastra/core/base';
+import fs from 'fs';
+import path, { dirname } from 'path';
+import type { PackageJson } from 'type-fest';
+import { fileURLToPath } from 'url';
+
+import fsExtra from 'fs-extra/esm';
+import fsPromises from 'fs/promises';
+
+import { createChildProcessLogger } from '../deploy/log.js';
+
+export class Deps extends MastraBase {
+  private packageManager: string;
+  private rootDir: string;
+
+  constructor(rootDir = process.cwd()) {
+    super({ component: 'DEPLOYER', name: 'DEPS' });
+
+    this.rootDir = rootDir;
+    this.packageManager = this.getPackageManager();
+  }
+
+  private findLockFile(dir: string): string | null {
+    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;
+  }
+
+  private getPackageManager(): string {
+    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';
+    }
+  }
+
+  public async install({ dir = this.rootDir, packages = [] }: { dir?: string; packages?: string[] }) {
+    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!,
+      },
+    });
+  }
+
+  public async installPackages(packages: string[]) {
+    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!,
+      },
+    });
+  }
+
+  public async checkDependencies(dependencies: string[]): Promise<string> {
+    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';
+    }
+  }
+
+  public 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;
+    }
+  }
+
+  public 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)) as PackageJson;
+    return content.version;
+  }
+
+  public async addScriptsToPackageJson(scripts: Record<string, string>) {
+    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));
+  }
+}

package/src/build/env.ts

@@ -0,0 +1,76 @@
+import * as fs from 'fs';
+
+export abstract class EnvService {
+  abstract getEnvValue(key: string): Promise<string | null>;
+  abstract setEnvValue(key: string, value: string): Promise<void>;
+}
+
+export class FileEnvService extends EnvService {
+  private filePath: string;
+
+  constructor(filePath: string) {
+    super();
+    this.filePath = filePath;
+  }
+
+  private readFile(filePath: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      fs.readFile(filePath, 'utf8', (err: NodeJS.ErrnoException | null, data: string) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
+  }
+
+  private writeFile({ filePath, data }: { filePath: string; data: string }): Promise<void> {
+    return new Promise((resolve, reject) => {
+      fs.writeFile(filePath, data, 'utf8', (err: NodeJS.ErrnoException | null) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+
+  private async updateEnvData({
+    key,
+    value,
+    filePath = this.filePath,
+    data,
+  }: {
+    key: string;
+    value: string;
+    filePath?: string;
+    data: string;
+  }): Promise<string> {
+    const regex = new RegExp(`^${key}=.*$`, 'm');
+    if (data.match(regex)) {
+      data = data.replace(regex, `${key}=${value}`);
+    } else {
+      data += `\n${key}=${value}`;
+    }
+    await this.writeFile({ filePath, data });
+    console.log(`${key} set to ${value} in ENV file.`);
+    return data;
+  }
+
+  async getEnvValue(key: string): Promise<string | null> {
+    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: string, value: string): Promise<void> {
+    try {
+      const data = await this.readFile(this.filePath);
+      await this.updateEnvData({ key, value, data });
+    } catch (err) {
+      console.error(`Error writing ENV value: ${err}`);
+    }
+  }
+}