mastra 0.1.57-alpha.90 → 0.1.57-unstable.101

package/dist/src/utils/bundle.d.ts

@@ -0,0 +1,43 @@
+import * as esbuild from 'esbuild';
+export declare function bundleServer(entryPoint: string): Promise<esbuild.BuildResult<{
+    entryPoints: string[];
+    bundle: true;
+    platform: "node";
+    format: "esm";
+    outfile: string;
+    target: string;
+    sourcemap: true;
+    mainFields: string[];
+    minify: false;
+    metafile: true;
+    logLevel: "error";
+    nodePaths: string[];
+    external: string[];
+    banner: {
+        js: string;
+    };
+    logOverride: {
+        'commonjs-variable-in-esm': "silent";
+    };
+}>>;
+export declare function bundle(dirPath: string): Promise<esbuild.BuildResult<{
+    entryPoints: string[];
+    bundle: true;
+    platform: "node";
+    format: "esm";
+    outfile: string;
+    target: string;
+    sourcemap: true;
+    minify: false;
+    metafile: true;
+    logLevel: "error";
+    mainFields: string[];
+    conditions: string[];
+    banner: {
+        js: string;
+    };
+    logOverride: {
+        'commonjs-variable-in-esm': "silent";
+    };
+    external: string[];
+}>>;

package/dist/src/utils/bundle.js

@@ -0,0 +1,183 @@
+import * as esbuild from 'esbuild';
+import { join } from 'path';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { upsertMastraDir } from '../commands/deploy/utils.js';
+import { getFirstExistingFile } from './get-first-existing-file.js';
+import { logger } from './logger.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function bundleServer(entryPoint) {
+    try {
+        // Ensure .mastra directory exists
+        upsertMastraDir();
+        const outfile = join(process.cwd(), '.mastra', 'server.mjs');
+        const cliNodeModules = join(path.dirname(path.dirname(__dirname)), 'node_modules');
+        const result = await esbuild.build({
+            entryPoints: [entryPoint],
+            bundle: true,
+            platform: 'node',
+            format: 'esm',
+            outfile,
+            target: 'node20',
+            sourcemap: true,
+            mainFields: ['module', 'main'],
+            minify: false, // Set to true if you want minification
+            metafile: true, // Generates build metadata
+            logLevel: 'error',
+            nodePaths: [cliNodeModules],
+            external: [
+                // Mark node built-ins as external
+                'fs',
+                'path',
+                'os',
+                'crypto',
+                'stream',
+                'util',
+                'events',
+                'http',
+                'https',
+                'net',
+                'tls',
+                'zlib',
+                'child_process',
+                'worker_threads',
+                'cluster',
+                'dns',
+                'dgram',
+                'readline',
+                'repl',
+                'tty',
+                'url',
+                'v8',
+                'vm',
+                'module',
+                'process',
+                // Your packages
+                '@mastra/core',
+                '@mastra/memory',
+                '@mastra/engine',
+                '@mastra/firecrawl',
+                '@mastra/github',
+            ],
+            banner: {
+                js: `
+          import { createRequire } from "module";
+          import { fileURLToPath } from 'url';
+          import path from 'path';
+          const require = createRequire(import.meta.url);
+          const __filename = fileURLToPath(import.meta.url);
+          const __dirname = path.dirname(__filename);
+        `,
+            },
+            logOverride: {
+                'commonjs-variable-in-esm': 'silent',
+            },
+        });
+        // Output build metadata
+        await esbuild.analyzeMetafile(result.metafile);
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message.includes('Missing required file,')) {
+                logger.info('Cannot find mastra: add your directory with --dir <dir>');
+            }
+        }
+        else {
+            console.error('Server build failed:', error);
+        }
+        process.exit(1);
+    }
+}
+export async function bundle(dirPath) {
+    try {
+        // Ensure .mastra directory exists
+        upsertMastraDir();
+        const entryPoint = getFirstExistingFile([join(dirPath, 'index.ts')]);
+        const outfile = join(process.cwd(), '.mastra', 'mastra.mjs');
+        const result = await esbuild.build({
+            entryPoints: [entryPoint],
+            bundle: true,
+            platform: 'node',
+            format: 'esm',
+            outfile,
+            target: 'node20',
+            sourcemap: true,
+            minify: false, // Set to true if you want minification
+            metafile: true, // Generates build metadata
+            logLevel: 'error',
+            mainFields: ['module', 'main'],
+            conditions: ['import', 'node'],
+            banner: {
+                js: `
+          import { createRequire } from 'module';
+          const require = createRequire(import.meta.url);
+        `,
+            },
+            logOverride: {
+                'commonjs-variable-in-esm': 'silent',
+            },
+            external: [
+                // Mark node built-ins as external
+                'assert',
+                'buffer',
+                'child_process',
+                'cluster',
+                'constants',
+                'crypto',
+                'dgram',
+                'dns',
+                'events',
+                'fs',
+                'http',
+                'http2',
+                'https',
+                'module',
+                'net',
+                'os',
+                'path',
+                'process',
+                'punycode',
+                'querystring',
+                'readline',
+                'repl',
+                'stream',
+                'string_decoder',
+                'sys',
+                'timers',
+                'tls',
+                'tty',
+                'url',
+                'util',
+                'v8',
+                'vm',
+                'wasi',
+                'worker_threads',
+                'zlib',
+                // Your packages
+                '@mastra/core',
+                '@mastra/memory',
+                '@mastra/engine',
+                '@mastra/firecrawl',
+                '@mastra/github',
+            ],
+        });
+        // Log build results
+        logger.success('Build completed successfully');
+        // Output build metadata
+        await esbuild.analyzeMetafile(result.metafile);
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message.includes('Missing required file,')) {
+                logger.info('Cannot find mastra: add your directory with --dir <dir>');
+            }
+        }
+        else {
+            console.error('Build failed:', error);
+        }
+        process.exit(1);
+    }
+}

package/dist/src/utils/copy-starter-file.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @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
+ */
+export declare function copyStarterFile(inputFile: string, outputFilePath: string, replaceIfExists?: boolean): Promise<boolean>;

package/dist/src/utils/copy-starter-file.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fsExtra from 'fs-extra/esm';
+/**
+ *
+ * @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
+ */
+export async function 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 = fs.readFileSync(filePath, 'utf8');
+    if (fs.existsSync(outputFilePath) && !replaceIfExists) {
+        console.log(`${outputFilePath} already exists`);
+        return false;
+    }
+    await fsExtra.outputFile(outputFilePath, fileString);
+    return true;
+}

package/dist/src/utils/find-api-keys.d.ts

@@ -0,0 +1,4 @@
+export declare function findApiKeys(): {
+    name: string;
+    value: string;
+}[];

package/dist/src/utils/find-api-keys.js

@@ -0,0 +1,7 @@
+export function findApiKeys() {
+    const apiKeyPattern = /_API_KEY$/;
+    const apiKeys = Object.entries(process.env)
+        .filter(([key, value]) => apiKeyPattern.test(key) && value)
+        .map(([key, value]) => ({ name: key, value }));
+    return apiKeys;
+}

package/dist/src/utils/find-first-directory.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Finds and returns the first available directory from an array of paths
+ * @param paths - Array of directory paths to check
+ * @returns The first valid directory path or null if none found
+ */
+export declare function findFirstDirectory(paths: string[]): string | null;

package/dist/src/utils/find-first-directory.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Finds and returns the first available directory from an array of paths
+ * @param paths - Array of directory paths to check
+ * @returns The first valid directory path or null if none found
+ */
+export function findFirstDirectory(paths) {
+    for (const pathToCheck of paths) {
+        try {
+            const normalizedPath = path.normalize(pathToCheck);
+            if (fs.existsSync(normalizedPath)) {
+                const stats = fs.statSync(normalizedPath);
+                if (stats.isDirectory()) {
+                    return normalizedPath;
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}

package/dist/src/utils/get-engine-path.d.ts

@@ -0,0 +1 @@
+export declare function getEnginePath(): string;

package/dist/src/utils/get-engine-path.js

@@ -0,0 +1,11 @@
+import path from 'path';
+import { getFirstExistingFile } from './get-first-existing-file.js';
+export function getEnginePath() {
+    const possibleEnginePaths = [
+        path.resolve(process.cwd(), 'node_modules', '@mastra/engine'),
+        path.resolve(process.cwd(), '..', 'node_modules', '@mastra/engine'),
+        path.resolve(process.cwd(), '..', '..', 'node_modules', '@mastra/engine'),
+        path.resolve(process.cwd(), './packages/engine'), // For CI
+    ];
+    return getFirstExistingFile(possibleEnginePaths);
+}

package/dist/src/utils/get-env.d.ts

@@ -0,0 +1 @@
+export declare function getEnv(): string;

package/dist/src/utils/get-env.js

@@ -0,0 +1,12 @@
+import dotenv from 'dotenv';
+import fs from 'fs';
+import path from 'node:path';
+export function getEnv() {
+    const projectDir = process.cwd();
+    const dotenvPath = path.join(projectDir, '.env.development');
+    if (fs.existsSync(dotenvPath)) {
+        dotenv.config({ path: dotenvPath });
+    }
+    const dbUrl = process.env.DB_URL || '';
+    return dbUrl;
+}

package/dist/src/utils/get-first-existing-file.d.ts

@@ -0,0 +1 @@
+export declare const getFirstExistingFile: (files: string[]) => string;

package/dist/src/utils/get-first-existing-file.js

@@ -0,0 +1,9 @@
+import fs from 'fs';
+export const getFirstExistingFile = (files) => {
+    for (const f of files) {
+        if (fs.existsSync(f)) {
+            return f;
+        }
+    }
+    throw new Error('Missing required file, checked the following paths: ' + files.join(', '));
+};

package/dist/src/utils/get-package-manager.d.ts

@@ -0,0 +1,2 @@
+declare const getPackageManager: () => "pnpm" | "npm" | "yarn";
+export default getPackageManager;

package/dist/src/utils/get-package-manager.js

@@ -0,0 +1,29 @@
+import fs from 'fs';
+import path from 'path';
+const findLockFile = (dir) => {
+    const lockFiles = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock'];
+    for (const file of lockFiles) {
+        if (fs.existsSync(path.join(dir, file))) {
+            return file;
+        }
+    }
+    const parentDir = path.resolve(dir, '..');
+    if (parentDir !== dir) {
+        return findLockFile(parentDir);
+    }
+    return null;
+};
+const getPackageManager = () => {
+    const lockFile = findLockFile(process.cwd());
+    switch (lockFile) {
+        case 'pnpm-lock.yaml':
+            return 'pnpm';
+        case 'package-lock.json':
+            return 'npm';
+        case 'yarn.lock':
+            return 'yarn';
+        default: // we will use npm if we can't figure it out
+            return 'npm';
+    }
+};
+export default getPackageManager;

package/dist/src/utils/get-package-version.d.ts

@@ -0,0 +1 @@
+export declare function getPackageVersion(): Promise<string>;

package/dist/src/utils/get-package-version.js

@@ -0,0 +1,10 @@
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import fsExtra from 'fs-extra/esm';
+export async function 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;
+}

package/dist/src/utils/get-project-name.d.ts

@@ -0,0 +1 @@
+export declare function getProjectName(): Promise<any>;

package/dist/src/utils/get-project-name.js

@@ -0,0 +1,13 @@
+import path from 'path';
+import fs from 'fs/promises';
+export async function getProjectName() {
+    try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        const packageJson = await fs.readFile(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(packageJson);
+        return pkg.name;
+    }
+    catch (err) {
+        throw err;
+    }
+}

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,8 @@
+export declare const logger: {
+    log(args: string): void;
+    error(args: string): void;
+    warn(args: string): void;
+    info(args: string): void;
+    success(args: string): void;
+    break(): void;
+};

package/dist/src/utils/logger.js

@@ -0,0 +1,21 @@
+import color from 'picocolors';
+export const logger = {
+    log(args) {
+        console.log(args);
+    },
+    error(args) {
+        console.log(color.red(args));
+    },
+    warn(args) {
+        console.log(color.yellow(args));
+    },
+    info(args) {
+        console.log(color.cyan(args));
+    },
+    success(args) {
+        console.log(color.green(args));
+    },
+    break() {
+        console.log('');
+    },
+};

package/dist/src/utils/port-utils.d.ts

@@ -0,0 +1,8 @@
+export declare const isPortOpen: (port: number) => Promise<boolean>;
+export declare function getInfraPorts({ defaultPostgresPort, }?: {
+    defaultAdminPort?: number;
+    defaultInngestPort?: number;
+    defaultPostgresPort?: number;
+}): Promise<{
+    postgresPort: number;
+}>;

package/dist/src/utils/port-utils.js

@@ -0,0 +1,25 @@
+import { check } from 'tcp-port-used';
+export const isPortOpen = async (port) => {
+    return new Promise(resolve => {
+        check(port).then((inUse) => {
+            resolve(!inUse);
+        });
+    });
+};
+const getNextOpenPort = async (startFrom = 2222) => {
+    for (const port of Array.from({ length: 20 }, (_, i) => startFrom + i)) {
+        const isOpen = await isPortOpen(port);
+        if (isOpen) {
+            return port;
+        }
+    }
+    throw new Error('No open ports found after 20 attempts');
+};
+export async function getInfraPorts({ defaultPostgresPort, } = {}) {
+    let postgresPort = defaultPostgresPort || 5432;
+    const dbPortOpen = await isPortOpen(postgresPort);
+    if (!dbPortOpen) {
+        postgresPort = (await getNextOpenPort(postgresPort));
+    }
+    return { postgresPort };
+}

package/dist/src/utils/replace-value-in-file.d.ts

@@ -0,0 +1,7 @@
+export declare function replaceValuesInFile({ filePath, replacements, }: {
+    filePath: string;
+    replacements: {
+        search: string;
+        replace: string;
+    }[];
+}): void;

package/dist/src/utils/replace-value-in-file.js

@@ -0,0 +1,8 @@
+import fs from 'fs';
+export function replaceValuesInFile({ filePath, replacements, }) {
+    let fileContent = fs.readFileSync(filePath, 'utf8');
+    replacements.forEach(({ search, replace }) => {
+        fileContent = fileContent.replaceAll(search, replace);
+    });
+    fs.writeFileSync(filePath, fileContent);
+}

package/dist/src/utils/sanitize-docker-name.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeForDockerName(name: string): string;

package/dist/src/utils/sanitize-docker-name.js

@@ -0,0 +1,16 @@
+export function sanitizeForDockerName(name) {
+    // Convert to lowercase
+    let sanitized = name.toLowerCase();
+    // Replace any non-alphanumeric characters (excluding dashes) with dashes
+    sanitized = sanitized.replace(/[^a-z0-9-]/g, '-');
+    // Trim dashes from the start and end
+    sanitized = sanitized.replace(/^-+|-+$/g, '');
+    // Ensure name is between 2 and 255 characters
+    if (sanitized.length < 2) {
+        throw new Error('Name must be at least 2 characters long.');
+    }
+    if (sanitized.length > 255) {
+        sanitized = sanitized.substring(0, 255);
+    }
+    return sanitized;
+}

package/dist/src/utils/setup-docker-compose.d.ts

@@ -0,0 +1,6 @@
+export declare function prepareDockerComposeFile({ sanitizedProjectName, postgresPort, }: {
+    sanitizedProjectName: string;
+    postgresPort: number;
+}): {
+    dbUrl: string;
+};

package/dist/src/utils/setup-docker-compose.js

@@ -0,0 +1,23 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { copyStarterFile } from './copy-starter-file.js';
+import { replaceValuesInFile } from './replace-value-in-file.js';
+const DOCKER_COMPOSE_FILE = 'mastra-pg.docker-compose.yaml';
+export function prepareDockerComposeFile({ sanitizedProjectName, postgresPort, }) {
+    let dbUrl = `postgresql://postgres:postgres@localhost:${postgresPort}/mastra`;
+    editDockerComposeFileForPG({ sanitizedProjectName, postgresPort });
+    copyStarterFile(DOCKER_COMPOSE_FILE, DOCKER_COMPOSE_FILE);
+    return { dbUrl: String(dbUrl) };
+}
+const editDockerComposeFileForPG = ({ sanitizedProjectName, postgresPort, }) => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const filePath = path.resolve(__dirname, '..', 'starter-files', DOCKER_COMPOSE_FILE);
+    replaceValuesInFile({
+        filePath,
+        replacements: [
+            { replace: sanitizedProjectName, search: 'REPLACE_PROJECT_NAME' },
+            { replace: `${postgresPort}`, search: 'REPLACE_DB_PORT' },
+        ],
+    });
+};

package/dist/src/utils/setup-env-file.d.ts

@@ -0,0 +1,3 @@
+export declare function setupEnvFile({ dbUrl }: {
+    dbUrl: string;
+}): Promise<void>;

package/dist/src/utils/setup-env-file.js

@@ -0,0 +1,9 @@
+import path from 'path';
+import fse from 'fs-extra/esm';
+import { FileEnvService } from '../services/service.fileEnv.js';
+export async function setupEnvFile({ dbUrl }) {
+    const envPath = path.join(process.cwd(), '.env.development');
+    await fse.ensureFile(envPath);
+    const fileEnvService = new FileEnvService(envPath);
+    await fileEnvService.setEnvValue('DB_URL', dbUrl);
+}

package/dist/src/utils/string.d.ts

@@ -0,0 +1 @@
+export declare const toCamelCase: (str: string) => string;

package/dist/src/utils/string.js

@@ -0,0 +1,22 @@
+export const toCamelCase = (str) => {
+    // If string is already camelCase with no spaces, return as is
+    if (/^[a-z][a-zA-Z0-9]*$/.test(str) && !str.includes(' ')) {
+        return str;
+    }
+    return str
+        .split(' ')
+        .filter(word => word.length > 0)
+        .map((word, index) => {
+        // If word contains hyphen, return as is
+        if (word.includes('-')) {
+            return word;
+        }
+        // If word is already camelCase, preserve its case
+        if (/^[a-z][a-zA-Z0-9]*$/.test(word)) {
+            return index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1);
+        }
+        // Otherwise convert to camelCase
+        return index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.toLowerCase().slice(1);
+    })
+        .join('');
+};

package/dist/starter-files/api.ts

@@ -0,0 +1,11 @@
+// @ts-ignore
+import { config } from '@mastra/config';
+import { Mastra } from '@mastra/core';
+
+const mastra = Mastra.init(config);
+
+const router = mastra.createRouter();
+
+const handler = router.registerRoutes();
+
+export { handler as GET, handler as POST, handler as PUT };

package/dist/starter-files/framework-utils.ts

@@ -0,0 +1,33 @@
+// @ts-ignore
+import * as MastraConfig from '!!CONFIG_PATH!!';
+// @ts-ignore
+import { Mastra } from '@mastra/core';
+import fs from 'fs';
+import path from 'path';
+
+const _config = MastraConfig.config;
+
+function getFramework() {
+  try {
+    const framework = Mastra.init(MastraConfig.config);
+
+    return { framework, config: _config };
+  } catch (error) {
+    console.error('Error loading config:', error);
+    return { framework: null, config: null };
+  }
+}
+
+export const { framework, config } = getFramework();
+
+// @todo: the .env file should be able to be set to .env.local somehow
+// possibly defined in the config file?
+export function getEnvPath() {
+  if (process.env.MASTRA_APP_DIR) {
+    const envPath = path.resolve(process.env.MASTRA_APP_DIR, '.env');
+    if (fs.existsSync(envPath)) {
+      return envPath;
+    }
+  }
+  return path.resolve(process.cwd(), '.env');
+}