@mastra/deployer 0.0.0-storage-20250225005900

package/src/build/plugins/fix-libsql.ts

@@ -0,0 +1,69 @@
+import * as babel from '@babel/core';
+import { currentTarget } from '@neon-rs/load';
+import { familySync, GLIBC } from 'detect-libc';
+import { dirname, join } from 'path';
+import type { Plugin } from 'rollup';
+
+import fsExtra from 'fs-extra/esm';
+
+import { rewriteLibsqlImport } from '../babel/fix-libsql';
+
+export function libSqlFix(): Plugin {
+  return {
+    name: 'libSqlFix',
+    transform(code, id) {
+      if (!id.includes('\\libsql\\index.js') && !id.includes('/libsql/index.js')) {
+        return null;
+      }
+
+      return new Promise((resolve, reject) => {
+        babel.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [rewriteLibsqlImport],
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+
+            resolve({
+              code: result!.code!,
+              map: result!.map!,
+            });
+          },
+        );
+      });
+    },
+    async generateBundle({ file, dir }) {
+      if (!file && !dir) {
+        throw new Error('No output options were given.');
+      }
+
+      const outputDirectory = dir || dirname(file!);
+
+      let target = currentTarget();
+      // Workaround for Bun, which reports a musl target, but really wants glibc...
+      if (familySync() == GLIBC) {
+        switch (target) {
+          case 'linux-x64-musl':
+            target = 'linux-x64-gnu';
+            break;
+          case 'linux-arm64-musl':
+            target = 'linux-arm64-gnu';
+            break;
+        }
+      }
+
+      const fileToCopy = await this.resolve(`@libsql/${target}/index.node`);
+      if (fileToCopy) {
+        await fsExtra.copy(fileToCopy.id, join(outputDirectory, 'libsql.node'));
+      } else {
+        // throw new Error(`libsql binding not found for @libsql/${target}/index.node`);
+      }
+    },
+  } satisfies Plugin;
+}

package/src/build/plugins/hono-alias.ts

@@ -0,0 +1,17 @@
+import { fileURLToPath } from 'node:url';
+import type { Plugin } from 'rollup';
+
+// hono is imported from deployer, so we need to resolve from here instead of the project root
+export function aliasHono(): Plugin {
+  return {
+    name: 'hono-alias',
+    resolveId(id: string) {
+      if (!id.startsWith('@hono/') && !id.startsWith('hono/') && id !== 'hono' && id !== 'hono-openapi') {
+        return;
+      }
+
+      const path = import.meta.resolve(id);
+      return fileURLToPath(path);
+    },
+  } satisfies Plugin;
+}

package/src/build/plugins/pino.ts

@@ -0,0 +1,93 @@
+import path from 'path';
+import type { OutputChunk, Plugin } from 'rollup';
+
+export function pino() {
+  let emittedChunks = new Map();
+
+  const workerFiles = [
+    {
+      id: 'thread-stream-worker',
+      file: 'pino-thread-stream-worker',
+    },
+    {
+      id: 'pino-worker',
+      file: 'pino-worker',
+    },
+    {
+      id: 'pino/file',
+      file: 'pino-file',
+    },
+    {
+      id: 'pino-pretty',
+      file: 'pino-pretty',
+    },
+  ];
+
+  const fileReferences = new Map();
+  return {
+    name: 'rollup-plugin-pino',
+
+    async resolveId(id, importee) {
+      if (id === 'pino') {
+        // resolve pino first
+        const resolvedPino = await this.resolve(id, importee);
+
+        if (resolvedPino) {
+          await Promise.all(
+            workerFiles.map(async file => {
+              const resolvedEntry = await this.resolve(file.id, resolvedPino.id);
+
+              if (!resolvedEntry) {
+                return null;
+              }
+
+              const reference = this.emitFile({
+                type: 'chunk',
+                id: resolvedEntry.id,
+                name: `${file.file}`,
+              });
+
+              fileReferences.set(file.id, reference);
+            }),
+          );
+        }
+      }
+    },
+    renderChunk(code, chunk) {
+      if (chunk.type === 'chunk' && (chunk as OutputChunk).isEntry && fileReferences.size && chunk.name === 'index') {
+        const importRegex = /^(?:import(?:["'\s]*[\w*${}\n\r\t, ]+from\s*)?["'\s].+[;"'\s]*)$/gm;
+
+        const codeToInject = `globalThis.__bundlerPathsOverrides = {
+            ${Array.from(fileReferences.entries())
+              .map(([key, file]) => {
+                return '"' + key + '": import.meta.ROLLUP_FILE_URL_' + file;
+              })
+              .join(',\n')}
+            };`;
+
+        // Find all import matches
+        const matches = Array.from(code.matchAll(importRegex));
+
+        if (matches.length > 0) {
+          // Get the last import's position
+          const lastImport = matches[matches.length - 1]!;
+          const lastImportEnd = lastImport.index + lastImport[0].length;
+
+          // Insert the code after the last import with a newline
+          const newCode = code.slice(0, lastImportEnd) + '\n\n' + codeToInject + '\n\n' + code.slice(lastImportEnd);
+
+          return {
+            code: newCode,
+            map: null,
+          };
+        }
+
+        // If no imports found, inject at the start of the file
+        return {
+          code: `${codeToInject}\n\n${code}`,
+          map: null,
+        };
+      }
+    },
+  } satisfies Plugin;
+}

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

@@ -0,0 +1,37 @@
+import * as babel from '@babel/core';
+import type { Plugin } from 'rollup';
+
+import { removeDeployer as removeDeployerBabelPlugin } from '../babel/remove-deployer';
+
+export function removeDeployer(mastraEntry: string): Plugin {
+  return {
+    name: 'remove-deployer',
+    transform(code, id) {
+      if (id !== mastraEntry) {
+        return;
+      }
+
+      return new Promise((resolve, reject) => {
+        babel.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [removeDeployerBabelPlugin],
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+
+            resolve({
+              code: result!.code!,
+              map: result!.map!,
+            });
+          },
+        );
+      });
+    },
+  } satisfies Plugin;
+}

package/src/build/plugins/telemetry-fix.ts

@@ -0,0 +1,54 @@
+import { dirname, resolve } from 'path';
+import { platform } from 'process';
+import type { Plugin } from 'rollup';
+
+function getTelemetryMachineFile() {
+  switch (platform) {
+    case 'darwin':
+      return 'getMachineId-darwin';
+    case 'linux':
+      return 'getMachineId-linux';
+    case 'freebsd':
+      return 'getMachineId-bsd';
+    case 'win32':
+      return 'getMachineId-win';
+    default:
+      return 'getMachineId-unsupported';
+  }
+}
+
+export function telemetryFix(): Plugin {
+  return {
+    name: 'telemetry-fix',
+    transform(code, id) {
+      if (id.includes('require-in-the-middle')) {
+        return code
+          .replace(
+            `const path = require('path')`,
+            `const path = require('path');
+      const { createRequire } = require('module');
+      const realRequire = createRequire(import.meta.url)`,
+          )
+          .replaceAll(`require.resolve`, `realRequire.resolve`);
+      }
+    },
+    resolveId(id: string, importer?: string) {
+      if (id === './machine-id/getMachineId' && importer) {
+        // rewrite dynamic require to correct file
+        return { id: resolve(dirname(importer), `./machine-id/${getTelemetryMachineFile()}.js`) };
+      }
+
+      if (id === 'formdata-node') {
+        return { id: 'formdata-node', external: false };
+      }
+    },
+    load(id: string) {
+      if (id.startsWith('formdata-node')) {
+        // Return an empty module
+        return 'export default {};';
+      }
+
+      return null;
+    },
+  } satisfies Plugin;
+}

package/src/build/telemetry.ts

@@ -0,0 +1,76 @@
+import * as babel from '@babel/core';
+import type { MastraDeployer } from '@mastra/core';
+import { rollup } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+
+import { removeAllExceptTelemetryConfig } from './babel/get-telemetry-config';
+
+export async function writeTelemetryConfig(
+  entryFile: string,
+  outputDir: string,
+): Promise<{
+  hasCustomConfig: boolean;
+}> {
+  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, 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 result;
+}

package/src/build/utils.ts

@@ -0,0 +1,12 @@
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+export function upsertMastraDir({ dir = process.cwd() }: { dir?: string }) {
+  const dirPath = join(dir, '.mastra');
+
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+    execSync(`echo ".mastra" >> .gitignore`);
+  }
+}

package/src/build/watcher.ts

@@ -0,0 +1,43 @@
+import type { InputOptions, OutputOptions } from 'rollup';
+import { watch } from 'rollup';
+
+import { getInputOptions as getBundlerInputOptions } from './bundler';
+import { aliasHono } from './plugins/hono-alias';
+
+export async function getInputOptions(entryFile: string, platform: 'node' | 'browser') {
+  const inputOptions = await getBundlerInputOptions(
+    entryFile,
+    {
+      dependencies: new Map(),
+      externalDependencies: new Set(),
+      invalidChunks: new Set(),
+    },
+    platform,
+  );
+
+  if (Array.isArray(inputOptions.plugins)) {
+    // filter out node-resolve plugin so all node_modules are external
+    inputOptions.plugins = inputOptions.plugins.filter(
+      // @ts-ignore
+      plugin => !plugin || !plugin?.name || plugin.name !== 'node-resolve',
+    );
+
+    inputOptions.plugins.push(aliasHono());
+  }
+
+  return inputOptions;
+}
+
+export async function createWatcher(inputOptions: InputOptions, outputOptions: OutputOptions) {
+  const watcher = await watch({
+    ...inputOptions,
+    output: {
+      ...outputOptions,
+      format: 'esm',
+      entryFileNames: '[name].mjs',
+      chunkFileNames: '[name].mjs',
+    },
+  });
+
+  return watcher;
+}

package/src/bundler/index.ts

@@ -0,0 +1,145 @@
+import { MastraBundler } from '@mastra/core/bundler';
+import virtual from '@rollup/plugin-virtual';
+import { copy, ensureDir } from 'fs-extra';
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { InputOptions, OutputOptions } from 'rollup';
+
+import fsExtra from 'fs-extra/esm';
+
+import { analyzeBundle } from '../build/analyze';
+import { createBundler as createBundlerUtil, getInputOptions } from '../build/bundler';
+import { Deps } from '../build/deps';
+import { writeTelemetryConfig } from '../build/telemetry';
+
+export abstract class Bundler extends MastraBundler {
+  protected analyzeOutputDir = '.build';
+  protected outputDir = 'output';
+
+  constructor(name: string, component: 'BUNDLER' | 'DEPLOYER' = 'BUNDLER') {
+    super({ name, component });
+  }
+
+  async prepare(outputDirectory: string): Promise<void> {
+    // Clean up the output directory first
+    await fsExtra.emptyDir(outputDirectory);
+
+    await ensureDir(join(outputDirectory, this.analyzeOutputDir));
+    await ensureDir(join(outputDirectory, this.outputDir));
+  }
+
+  async writeInstrumentationFile(outputDirectory: string) {
+    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: string, dependencies: Map<string, string>) {
+    this.logger.debug(`Writing project's package.json`);
+    await ensureDir(outputDirectory);
+    const pkgPath = join(outputDirectory, 'package.json');
+
+    const dependenciesMap = 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,
+      ),
+    );
+  }
+
+  protected createBundler(inputOptions: InputOptions, outputOptions: Partial<OutputOptions> & { dir: string }) {
+    return createBundlerUtil(inputOptions, outputOptions);
+  }
+
+  protected async analyze(entry: string, mastraFile: string, outputDirectory: string) {
+    return await analyzeBundle(entry, mastraFile, join(outputDirectory, this.analyzeOutputDir), 'node', this.logger);
+  }
+
+  protected async installDependencies(outputDirectory: string, rootDir = process.cwd()) {
+    const deps = new Deps(rootDir);
+    deps.__setLogger(this.logger);
+
+    await deps.install({ dir: join(outputDirectory, this.outputDir) });
+  }
+
+  protected async _bundle(
+    serverFile: string,
+    mastraEntryFile: string,
+    outputDirectory: string,
+    bundleLocation: string = join(outputDirectory, this.outputDir),
+  ): Promise<void> {
+    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;
+    }, new Map<string, string>());
+
+    await this.writePackageJson(join(outputDirectory, this.outputDir), dependenciesToInstall);
+    await this.writeInstrumentationFile(join(outputDirectory, this.outputDir));
+
+    this.logger.info('Bundling Mastra application');
+    const inputOptions: 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');
+  }
+}

package/src/deploy/base.ts

@@ -0,0 +1,30 @@
+import type { IDeployer } from '@mastra/core/deployer';
+
+import { Deps } from '../build/deps.js';
+import { FileService } from '../build/fs';
+import { Bundler } from '../bundler';
+
+export abstract class Deployer extends Bundler implements IDeployer {
+  deps: Deps = new Deps();
+
+  constructor(args: { name: string }) {
+    super(args.name, 'DEPLOYER');
+
+    this.deps.__setLogger(this.logger);
+  }
+
+  getEnvFiles(): Promise<string[]> {
+    const possibleFiles = ['.env.production', '.env'];
+
+    try {
+      const fileService = new FileService();
+      const envFile = fileService.getFirstExistingFile(possibleFiles);
+
+      return Promise.resolve([envFile]);
+    } catch {}
+
+    return Promise.resolve([]);
+  }
+
+  abstract deploy(outputDirectory: string): Promise<void>;
+}

package/src/deploy/index.ts

@@ -0,0 +1,2 @@
+export * from './base.js';
+export * from './log.js';

package/src/deploy/log.ts

@@ -0,0 +1,61 @@
+import type { Logger } from '@mastra/core/logger';
+import { spawn } from 'child_process';
+import { Transform } from 'stream';
+
+export const createPinoStream = (logger: Logger) => {
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      // Convert Buffer/string to string and trim whitespace
+      const line = chunk.toString().trim();
+
+      if (line) {
+        console.log(line);
+        // Log each line through Pino
+        logger.info(line);
+      }
+
+      // Pass through the original data
+      callback(null, chunk);
+    },
+  });
+};
+
+export function createChildProcessLogger({ logger, root }: { logger: Logger; root: string }) {
+  const pinoStream = createPinoStream(logger);
+  return async ({ cmd, args, env }: { cmd: string; args: string[]; env: Record<string, string> }) => {
+    try {
+      const subprocess = spawn(cmd, args, {
+        cwd: root,
+        shell: true,
+        env,
+      });
+
+      // Pipe stdout and stderr through the Pino stream
+      subprocess.stdout?.pipe(pinoStream);
+      subprocess.stderr?.pipe(pinoStream);
+
+      // Wait for the process to complete
+      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 };
+    }
+  };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './deploy';
+export { Deps, FileService } from './build';
+export { getDeployer } from './build/deployer';