mastra 0.1.57-alpha.9 → 0.1.57-unstable.34

package/dist/src/commands/deploy/index.js

@@ -0,0 +1,237 @@
+import * as prompts from '@clack/prompts';
+import color from 'picocolors';
+import { logger } from '../../utils/logger.js';
+import { CloudflareDeployer } from './cloudflare/index.js';
+import { NetlifyDeployer } from './netlify/index.js';
+import { getCreds, writeCreds } from './utils.js';
+import { VercelDeployer } from './vercel/index.js';
+async function fetchVercelTeams(authToken) {
+    if (!authToken) {
+        throw new Error('Authentication token is required');
+    }
+    const headers = {
+        Authorization: `Bearer ${authToken}`,
+        'Content-Type': 'application/json',
+    };
+    try {
+        const response = await fetch('https://api.vercel.com/v2/teams', {
+            method: 'GET',
+            headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch teams: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.teams
+            ?.filter(({ membership }) => membership.role === 'OWNER')
+            ?.map(({ slug }) => slug);
+    }
+    catch (error) {
+        console.error('Error fetching teams:', error);
+        throw error;
+    }
+}
+export async function vercelDeploy({ dir }) {
+    prompts.intro(color.inverse(' Deploying to Vercel '));
+    const creds = getCreds('VERCEL');
+    let token;
+    let scope;
+    if (!creds) {
+        const v = await prompts.text({
+            message: 'Provide a Vercel authorization token',
+        });
+        if (prompts.isCancel(v)) {
+            prompts.cancel('Deployment cancelled.');
+            process.exit(0);
+        }
+        if (!v) {
+            logger.log('No token provided, exiting...');
+            return;
+        }
+        const teams = await fetchVercelTeams(v);
+        scope = (await prompts.select({
+            message: 'Choose a team',
+            options: teams.map((slug) => {
+                return {
+                    value: slug,
+                    label: slug,
+                };
+            }),
+        }));
+        token = v;
+        logger.log(`Saving Team and Token to .mastra/creds.json: ${scope}`);
+        writeCreds({ scope, token, name: `VERCEL` });
+    }
+    else {
+        logger.log('Using existing Vercel credentials from .mastra/creds.json');
+        token = creds.token;
+        scope = creds.scope;
+    }
+    const deployer = new VercelDeployer({ token });
+    await deployer.deploy({ scope, dir });
+    logger.log('Deployment complete!');
+    process.exit(0);
+}
+async function getCloudflareAccountId(authToken) {
+    const response = await fetch('https://api.cloudflare.com/client/v4/accounts', {
+        headers: {
+            Authorization: `Bearer ${authToken}`,
+            'Content-Type': 'application/json',
+        },
+    });
+    const data = await response.json();
+    if (!response.ok) {
+        throw new Error(`Failed to get account ID: ${data.errors?.[0]?.message || 'Unknown error'}`);
+    }
+    // Returns the first account ID found
+    return data.result;
+}
+export async function cloudflareDeploy({ dir }) {
+    prompts.intro(color.inverse(' Deploying to Cloudflare '));
+    const creds = getCreds('CLOUDFLARE');
+    let token;
+    let scope;
+    if (!creds) {
+        const v = await prompts.text({
+            message: 'Provide a Cloudflare authorization token',
+        });
+        if (prompts.isCancel(v)) {
+            prompts.cancel('Deployment cancelled.');
+            process.exit(0);
+        }
+        if (!v) {
+            logger.log('No token provided, exiting...');
+            return;
+        }
+        const teams = await getCloudflareAccountId(v);
+        scope = (await prompts.select({
+            message: 'Choose a team',
+            options: teams.map(({ name, id }) => {
+                return {
+                    value: id,
+                    label: name,
+                };
+            }),
+        }));
+        token = v;
+        logger.log(`Saving Team and Token to .mastra/creds.json: ${scope}`);
+        writeCreds({ scope, token, name: `CLOUDFLARE` });
+    }
+    else {
+        logger.log('Using existing Cloudflare credentials from .mastra/creds.json');
+        token = creds.token;
+        scope = creds.scope;
+    }
+    const deployer = new CloudflareDeployer({ token });
+    await deployer.deploy({ scope, dir });
+    logger.log('Deployment complete!');
+    process.exit(0);
+}
+async function getNetlifyTeams(authToken) {
+    const response = await fetch('https://api.netlify.com/api/v1/accounts', {
+        headers: {
+            Authorization: `Bearer ${authToken}`,
+            'Content-Type': 'application/json',
+        },
+    });
+    const data = await response.json();
+    if (!response.ok) {
+        throw new Error(`Failed to get teams: ${data.message || 'Unknown error'}`);
+    }
+    // Returns array of teams/accounts with their slugs
+    return data.map((account) => ({
+        name: account.name,
+        slug: account.slug,
+        // The slug is what you'll need for the deploy command
+    }));
+}
+async function createNetlifySite(authToken, name, accountId) {
+    const response = await fetch('https://api.netlify.com/api/v1/sites', {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${authToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            name: name,
+            account_slug: accountId, // Optional - if not provided, creates in user's default account
+            force_ssl: true, // Enable HTTPS
+        }),
+    });
+    const data = await response.json();
+    if (!response.ok) {
+        throw new Error(`Failed to create site: ${data.message || 'Unknown error'}`);
+    }
+    return {
+        id: data.id,
+        name: data.name,
+        url: data.ssl_url || data.url,
+        adminUrl: data.admin_url,
+    };
+}
+async function findNetlifySite(authToken, name) {
+    const response = await fetch(`https://api.netlify.com/api/v1/sites?filter=all&name=${name}`, {
+        headers: {
+            Authorization: `Bearer ${authToken}`,
+            'Content-Type': 'application/json',
+        },
+    });
+    const data = await response.json();
+    if (!response.ok) {
+        throw new Error(`Failed to search sites: ${data.message || 'Unknown error'}`);
+    }
+    // Find exact match (filter can return partial matches)
+    return data.find((site) => site.name === name);
+}
+async function getOrCreateSite(authToken, name, scope) {
+    const existingSite = await findNetlifySite(authToken, name);
+    if (existingSite) {
+        return existingSite;
+    }
+    return createNetlifySite(authToken, name, scope);
+}
+export async function netlifyDeploy({ dir }) {
+    prompts.intro(color.inverse(' Deploying to Netlify '));
+    const creds = getCreds('NETLIFY');
+    let token;
+    let scope;
+    let siteId;
+    if (!creds) {
+        const v = await prompts.text({
+            message: 'Provide a Netlify authorization token',
+        });
+        if (!v) {
+            logger.log('No token provided, exiting...');
+            return;
+        }
+        if (prompts.isCancel(v)) {
+            prompts.cancel('Deployment cancelled.');
+            process.exit(0);
+        }
+        const teams = await getNetlifyTeams(v);
+        scope = (await prompts.select({
+            message: 'Choose a team',
+            options: teams.map(({ name, slug }) => {
+                return {
+                    value: slug,
+                    label: name,
+                };
+            }),
+        }));
+        token = v;
+        const s = await getOrCreateSite(token, 'mastra', scope);
+        logger.log(`Saving Team and Token to .mastra/creds.json: ${scope}`);
+        writeCreds({ scope, token, name: `NETLIFY`, siteId: s.id });
+        siteId = s.id;
+    }
+    else {
+        logger.log('Using existing Netlify credentials from .mastra/creds.json');
+        token = creds.token;
+        scope = creds.scope;
+        siteId = creds.siteId;
+    }
+    const deployer = new NetlifyDeployer({ token });
+    await deployer.deploy({ scope, siteId, dir });
+    logger.log('Deployment complete!');
+    process.exit(0);
+}

package/dist/src/commands/deploy/netlify/index.d.ts

@@ -0,0 +1,12 @@
+import { Deployer } from '../deployer.js';
+export declare class NetlifyDeployer extends Deployer {
+    name: string;
+    ensureNetlifyFolder(): void;
+    installCli(): Promise<void>;
+    writePkgJson(): Promise<void>;
+    writeFiles(): void;
+    deployCommand({ scope, siteId }: {
+        siteId: string;
+        scope: string;
+    }): Promise<void>;
+}

package/dist/src/commands/deploy/netlify/index.js

@@ -0,0 +1,66 @@
+import { execa } from 'execa';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import getPackageManager from '../../../utils/get-package-manager.js';
+import { Deployer } from '../deployer.js';
+import { NETLIFY } from '../server.js';
+export class NetlifyDeployer extends Deployer {
+    constructor() {
+        super(...arguments);
+        this.name = 'Netlify';
+    }
+    ensureNetlifyFolder() {
+        if (!existsSync(join(this.dotMastraPath, 'netlify/functions'))) {
+            mkdirSync(join(this.dotMastraPath, 'netlify/functions'), { recursive: true });
+        }
+    }
+    async installCli() {
+        console.log('Installing Netlify CLI...');
+        const p = execa(getPackageManager(), ['install', 'netlify-cli', '-g']);
+        p.stdout.pipe(process.stdout);
+        await p;
+    }
+    async writePkgJson() {
+        writeFileSync(join(this.dotMastraPath, 'package.json'), JSON.stringify({
+            name: 'server',
+            version: '1.0.0',
+            description: '',
+            main: 'api.mjs',
+            type: 'module',
+            scripts: {
+                start: 'node ./api.mjs',
+            },
+            author: '',
+            license: 'ISC',
+            dependencies: {
+                '@mastra/core': '0.1.27-alpha.18',
+                'serverless-http': 'latest',
+                '@netlify/functions': 'latest',
+                express: '^4.21.1',
+            },
+        }, null, 2));
+    }
+    writeFiles() {
+        // TODO ENV KEYS
+        writeFileSync(join(this.dotMastraPath, 'netlify.toml'), `
+        [functions]
+        external_node_modules = ["express", "serverless-http"]
+        node_bundler = "esbuild"
+        directory = "/"
+        [[redirects]]
+        force = true
+        from = "/*"
+        status = 200
+        to = "/.netlify/functions/api/:splat"
+        `);
+        writeFileSync(join(this.dotMastraPath, 'api.mjs'), NETLIFY);
+    }
+    async deployCommand({ scope, siteId }) {
+        console.log(scope, siteId);
+        const p2 = execa('netlify', ['deploy', '--site', siteId, '--auth', this.token, '--dir', '.', '--functions', '.'], {
+            cwd: this.dotMastraPath,
+        });
+        p2.stdout.pipe(process.stdout);
+        await p2;
+    }
+}

package/dist/src/commands/deploy/server.d.ts

@@ -0,0 +1,8 @@
+export declare const SERVER_TEMPLATES: {
+    express: string;
+    netlify: string;
+    worker: string;
+};
+export declare const EXPRESS_SERVER: string;
+export declare const NETLIFY: string;
+export declare const WORKER: string;

package/dist/src/commands/deploy/server.js

@@ -0,0 +1,14 @@
+import { readFileSync } from 'fs';
+import path, { join } from 'path';
+import { fileURLToPath } from 'url';
+export const SERVER_TEMPLATES = {
+    express: '../../templates/express-server.js',
+    netlify: '../../templates/netlify.js',
+    worker: '../../templates/worker.js',
+};
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const readTemplate = (path) => readFileSync(join(__dirname, path), 'utf-8');
+export const EXPRESS_SERVER = readTemplate(SERVER_TEMPLATES.express);
+export const NETLIFY = readTemplate(SERVER_TEMPLATES.netlify);
+export const WORKER = readTemplate(SERVER_TEMPLATES.worker);

package/dist/src/commands/deploy/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function upsertMastraDir(): void;
+export declare function writeCreds({ name, scope, token, siteId, }: {
+    siteId?: string;
+    name: string;
+    scope: string;
+    token: string;
+}): void;
+export declare function getCreds(name: string): any;

package/dist/src/commands/deploy/utils.js

@@ -0,0 +1,30 @@
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+export function upsertMastraDir() {
+    const dirPath = join(process.cwd(), '.mastra');
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath);
+        execSync(`echo ".mastra" >> .gitignore`);
+    }
+}
+export function writeCreds({ name, scope, token, siteId, }) {
+    upsertMastraDir();
+    const creds = getCreds(name);
+    writeFileSync(join(process.cwd(), `.mastra`, 'creds.json'), JSON.stringify({
+        ...(creds || {}),
+        [name]: {
+            scope,
+            token,
+            siteId,
+        },
+    }));
+}
+export function getCreds(name) {
+    try {
+        return JSON.parse(readFileSync(join(process.cwd(), `.mastra`, 'creds.json'), 'utf-8'))[name];
+    }
+    catch (error) {
+        return null;
+    }
+}

package/dist/src/commands/deploy/vercel/index.d.ts

@@ -0,0 +1,14 @@
+import { Deployer } from '../deployer.js';
+export declare class VercelDeployer extends Deployer {
+    name: string;
+    installCli(): Promise<void>;
+    writePkgJson(): Promise<void>;
+    writeFiles(): void;
+    private getProjectId;
+    syncEnv({ scope }: {
+        scope: string;
+    }): Promise<void>;
+    deployCommand({ scope }: {
+        scope: string;
+    }): Promise<void>;
+}

package/dist/src/commands/deploy/vercel/index.js

@@ -0,0 +1,144 @@
+import { execa } from 'execa';
+import { writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import getPackageManager from '../../../utils/get-package-manager.js';
+import { Deployer } from '../deployer.js';
+import { EXPRESS_SERVER } from '../server.js';
+export class VercelDeployer extends Deployer {
+    constructor() {
+        super(...arguments);
+        this.name = 'Vercel';
+    }
+    async installCli() {
+        console.log('Installing Vercel CLI...');
+        const p = execa(getPackageManager(), ['install', 'vercel', '-g']);
+        p.stdout.pipe(process.stdout);
+        await p;
+    }
+    async writePkgJson() {
+        writeFileSync(join(this.dotMastraPath, 'package.json'), JSON.stringify({
+            name: 'server',
+            version: '1.0.0',
+            description: '',
+            main: 'index.mjs',
+            scripts: {
+                start: 'node ./index.mjs',
+            },
+            author: '',
+            license: 'ISC',
+            dependencies: {
+                express: '^4.21.1',
+                '@mastra/core': '0.1.27-alpha.18',
+            },
+        }, null, 2));
+    }
+    writeFiles() {
+        writeFileSync(join(this.dotMastraPath, 'vercel.json'), JSON.stringify({
+            version: 2,
+            builds: [
+                {
+                    src: 'index.mjs',
+                    use: '@vercel/node',
+                    config: { includeFiles: ['**'] },
+                },
+            ],
+            routes: [
+                {
+                    src: '/(.*)',
+                    dest: 'index.mjs',
+                },
+            ],
+        }, null, 2));
+        writeFileSync(join(this.dotMastraPath, 'index.mjs'), EXPRESS_SERVER);
+    }
+    getProjectId() {
+        const projectJsonPath = join(this.dotMastraPath, '.vercel', 'project.json');
+        try {
+            const projectJson = JSON.parse(readFileSync(projectJsonPath, 'utf-8'));
+            return projectJson.projectId;
+        }
+        catch (error) {
+            throw new Error('Could not find project ID. Make sure the project has been deployed first.');
+        }
+    }
+    async syncEnv({ scope }) {
+        const envFiles = this.getEnvFiles();
+        const envVars = [];
+        for (const file of envFiles) {
+            const vars = this.parseEnvFile(file);
+            envVars.push(...vars);
+        }
+        console.log('Syncing environment variables...');
+        // Transform env vars into the format expected by Vercel API
+        const vercelEnvVars = envVars.map(envVar => {
+            const [key, value] = envVar.split('=');
+            if (!key || !value) {
+                throw new Error(`Invalid environment variable format: ${envVar}`);
+            }
+            return {
+                key,
+                value,
+                target: ['production', 'preview', 'development'],
+                type: 'plain',
+            };
+        });
+        try {
+            const projectId = this.getProjectId();
+            const response = await fetch(`https://api.vercel.com/v10/projects/${projectId}/env?teamId=${scope}&upsert=true`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(vercelEnvVars),
+            });
+            if (!response.ok) {
+                const error = (await response.json());
+                throw new Error(`Failed to sync environment variables: ${error.message}`);
+            }
+            console.log('✓ Successfully synced environment variables');
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error('Failed to sync environment variables:', error.message);
+            }
+            else {
+                console.error('Failed to sync environment variables:', error);
+            }
+            throw error;
+        }
+    }
+    async deployCommand({ scope }) {
+        // Get env vars for initial deployment
+        const envFiles = this.getEnvFiles();
+        const envVars = [];
+        for (const file of envFiles) {
+            const vars = this.parseEnvFile(file);
+            envVars.push(...vars);
+        }
+        // Create the command array with base arguments
+        const commandArgs = [
+            '--scope',
+            scope,
+            '--cwd',
+            join(process.cwd(), '.mastra'),
+            'deploy',
+            '--token',
+            this.token,
+            '--yes',
+        ];
+        // Add env vars to initial deployment
+        for (const envVar of envVars) {
+            commandArgs.push('--env', envVar);
+        }
+        // Run the Vercel deploy command
+        console.log('Running command:', 'vercel', commandArgs.join(' '));
+        const p2 = execa('vercel', commandArgs);
+        p2.stdout.pipe(process.stdout);
+        p2.stderr.pipe(process.stderr);
+        console.log('Deployment started on Vercel. You can wait for it to finish or exit this command.');
+        await p2;
+        // Sync environment variables for future deployments
+        await this.syncEnv({ scope });
+    }
+}

package/dist/src/commands/dev.d.ts

@@ -0,0 +1,10 @@
+export declare function dev({ port, env, dir }: {
+    dir?: string;
+    port: number;
+    env: Record<string, any>;
+}): Promise<import("execa").Result<{
+    cwd: string;
+    env: {
+        port: string;
+    };
+}>>;

package/dist/src/commands/dev.js

@@ -0,0 +1,47 @@
+import { config } from 'dotenv';
+import { execa } from 'execa';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fsExtra from 'fs-extra/esm';
+import fs from 'fs/promises';
+import { bundle, bundleServer } from '../utils/bundle.js';
+import { getFirstExistingFile } from '../utils/get-first-existing-file.js';
+import { EXPRESS_SERVER } from './deploy/server.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function dev({ port, env, dir }) {
+    const dotMastraPath = join(process.cwd(), '.mastra');
+    const agentChatServePath = join(dotMastraPath, 'agent-chat');
+    const key = env[0]?.name;
+    const value = env[0]?.value;
+    // Ensure agent-chat directory exists
+    await fsExtra.ensureDir(agentChatServePath);
+    // Copy agent-chat dist files
+    await fsExtra.copy(join(path.dirname(path.dirname(__dirname)), 'src/chat/agent/dist'), agentChatServePath, {
+        overwrite: true,
+    });
+    try {
+        const envFile = getFirstExistingFile(['.env.development', '.env']);
+        config({ path: envFile });
+    }
+    catch (err) {
+        //create .env file
+        await fsExtra.ensureFile('.env');
+        await fs.writeFile(path.join(process.cwd(), '.env'), `${key}=${value}`);
+    }
+    const dirPath = dir || path.join(process.cwd(), 'src/mastra');
+    await bundle(dirPath);
+    writeFileSync(join(dotMastraPath, 'index.mjs'), EXPRESS_SERVER);
+    await bundleServer(join(dotMastraPath, 'index.mjs'));
+    const proc = execa('node', ['server.mjs'], {
+        cwd: dotMastraPath,
+        env: {
+            port: `${port} || 4111`,
+        },
+    });
+    proc.stdout.pipe(process.stdout);
+    proc.stderr.pipe(process.stderr);
+    return proc;
+}

package/dist/src/commands/generate.d.ts

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

package/dist/src/commands/generate.js

@@ -0,0 +1,66 @@
+import { execa } from 'execa';
+import path from 'path';
+import yoctoSpinner from 'yocto-spinner';
+import fsExtra from 'fs-extra/esm';
+import { getEnginePath } from '../utils/get-engine-path.js';
+import getPackageManager from '../utils/get-package-manager.js';
+const spinner = yoctoSpinner({ text: 'Generating drizzle client\n' });
+const checkDrizzleInstallation = async () => {
+    const pkgJsonPath = path.join(process.cwd(), 'package.json');
+    const pkgJson = (await fsExtra.readJSON(pkgJsonPath));
+    if (pkgJson.dependencies && !pkgJson.dependencies['drizzle-kit']) {
+        return false;
+    }
+    else {
+        return true;
+    }
+};
+const installDrizzleKit = async () => {
+    const packageManager = getPackageManager();
+    let runCommand = packageManager;
+    if (packageManager === 'npm') {
+        runCommand = `${packageManager} i`;
+    }
+    else {
+        runCommand = `${packageManager} add`;
+    }
+    await execa(`${runCommand} drizzle-kit`, {
+        all: true,
+        shell: true,
+        stdio: 'inherit',
+    });
+};
+export async function generate(dbUrl) {
+    try {
+        spinner.start();
+        const isDrizzleInstalled = await checkDrizzleInstallation();
+        if (!isDrizzleInstalled) {
+            spinner.text = 'Installing drizzle kit\n';
+            await installDrizzleKit();
+        }
+        await generateDrizzleClient(dbUrl);
+        spinner.success('Drizzle client generated\n');
+    }
+    catch (err) {
+        spinner.error('Could not generate drizzle client\n');
+        console.error(err);
+    }
+}
+async function generateDrizzleClient(dbUrl) {
+    const enginePath = getEnginePath();
+    try {
+        await execa(`npx drizzle-kit generate --out=./dist/postgres/drizzle --dialect=postgresql --schema=./dist/postgres/db/schema.js`, {
+            env: {
+                ...process.env,
+                DB_URL: dbUrl,
+            },
+            cwd: enginePath,
+            shell: true,
+            all: true,
+            stdio: 'inherit', // inherit will pipe directly to parent process stdout/stderr
+        });
+    }
+    catch (err) {
+        throw err;
+    }
+}

package/dist/src/commands/init/init.d.ts

@@ -0,0 +1,10 @@
+import { LLMProvider } from './utils.js';
+export declare const init: ({ directory, addExample, components, llmProvider, showSpinner, }: {
+    directory: string;
+    components: string[];
+    llmProvider: LLMProvider;
+    addExample: boolean;
+    showSpinner?: boolean;
+}) => Promise<{
+    success: boolean;
+}>;