@mastra/deployer 0.2.5 → 0.2.6-alpha.10

package/dist/chunk-KFOGAPGX.cjs

@@ -1,433 +0,0 @@
-'use strict';
-
-var child_process = require('child_process');
-var stream = require('stream');
-var base = require('@mastra/core/base');
-var fs = require('fs');
-var path = require('path');
-var url = require('url');
-var fsExtra = require('fs-extra/esm');
-var fsPromises = require('fs/promises');
-var babel = require('@babel/core');
-var rollup = require('rollup');
-var esbuild = require('rollup-plugin-esbuild');
-var commonjs = require('@rollup/plugin-commonjs');
-
-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 fs__default = /*#__PURE__*/_interopDefault(fs);
-var path__default = /*#__PURE__*/_interopDefault(path);
-var fsExtra__default = /*#__PURE__*/_interopDefault(fsExtra);
-var fsPromises__default = /*#__PURE__*/_interopDefault(fsPromises);
-var babel__namespace = /*#__PURE__*/_interopNamespace(babel);
-var esbuild__default = /*#__PURE__*/_interopDefault(esbuild);
-var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
-
-// 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 (fs__default.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";
-    }
-  }
-  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__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 = JSON.parse(await fsPromises__default.default.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__default.default.join(this.rootDir, "package.json");
-      const packageJson = await fsPromises__default.default.readFile(packageJsonPath, "utf-8");
-      const pkg = JSON.parse(packageJson);
-      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-KFOGAPGX.cjs', document.baseURI).href)));
-    const __dirname = path.dirname(__filename);
-    const pkgJsonPath = path__default.default.join(__dirname, "..", "..", "package.json");
-    const content = await fsExtra__default.default.readJSON(pkgJsonPath);
-    return content.version;
-  }
-  async addScriptsToPackageJson(scripts) {
-    const packageJson = JSON.parse(await fsPromises__default.default.readFile("package.json", "utf-8"));
-    packageJson.scripts = {
-      ...packageJson.scripts,
-      ...scripts
-    };
-    await fsPromises__default.default.writeFile("package.json", JSON.stringify(packageJson, null, 2));
-  }
-};
-function removeAllExceptTelemetryConfig(result) {
-  const t = babel__namespace.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__namespace.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__namespace.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.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: [removeAllExceptTelemetryConfig(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 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);
-  await bundle.write({
-    dir: outputDir,
-    format: "es",
-    entryFileNames: "[name].mjs"
-  });
-  return result;
-}
-
-exports.Deps = Deps;
-exports.createChildProcessLogger = createChildProcessLogger;
-exports.createPinoStream = createPinoStream;
-exports.recursiveRemoveNonReferencedNodes = recursiveRemoveNonReferencedNodes;
-exports.writeTelemetryConfig = writeTelemetryConfig;

package/dist/chunk-PUX2FDGX.js

@@ -1,252 +0,0 @@
-import { aliasHono } from './chunk-UTZ3434D.js';
-import { getInputOptions } from './chunk-XEFBJH3T.js';
-import { removeDeployer } from './chunk-WVBUOQT6.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: "smallest",
-    preserveSymlinks: true,
-    external: [
-      ...nodeBuiltins,
-      ...nodeBuiltins.map((builtin) => "node:" + builtin),
-      ...inputOptions.external ?? []
-    ],
-    plugins: [
-      ...inputOptions.plugins ?? [],
-      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-*/*'],
-      }),
-      // 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 };