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

package/dist/templates/worker.js

@@ -1,11 +1,9 @@
 import { AutoRouter } from 'itty-router';
-// import { join } from 'path';
+import { join } from 'path';
 import { stringify } from 'superjson';
 import { pathToFileURL } from 'url';
 import zodToJsonSchema from 'zod-to-json-schema';
-// // @ts-ignore
-// import { mastra } from './mastra.mjs';
-// const { mastra } = await import(join(process.cwd(), 'mastra.mjs'));
+const { mastra } = await import(join(process.cwd(), 'mastra.mjs'));
 const mastraToolsPaths = process.env.MASTRA_TOOLS_PATH;
 const toolImports = mastraToolsPaths
     ? await Promise.all(mastraToolsPaths.split(',').map(async (toolPath) => {
@@ -18,13 +16,7 @@ const tools = toolImports.reduce((acc, toolModule) => {
     });
     return acc;
 }, {});
-async function addMastra(request) {
-    // @ts-ignore
-    const { mastra } = await import('./mastra.mjs');
-    request.mastra = mastra;
-}
 const router = AutoRouter();
-router.all('*', addMastra);
 const validateBody = async (body) => {
     const errorResponse = Object.entries(body).reduce((acc, [key, value]) => {
         if (!value) {
@@ -42,7 +34,7 @@ router.get('/', () => {
         headers: { 'Content-Type': 'text/plain' },
     });
 });
-router.get('/api/agents', async ({ mastra }) => {
+router.get('/api/agents', async () => {
     try {
         const agents = mastra.getAgents();
         const serializedAgents = Object.entries(agents).reduce((acc, [_id, _agent]) => {
@@ -79,7 +71,7 @@ router.get('/api/agents', async ({ mastra }) => {
         });
     }
 });
-router.get('/api/agents/:agentId', ({ params, mastra }) => {
+router.get('/api/agents/:agentId', ({ params }) => {
     try {
         const agentId = decodeURIComponent(params.agentId);
         const agent = mastra.getAgent(agentId);
@@ -112,7 +104,7 @@ router.get('/api/agents/:agentId', ({ params, mastra }) => {
         });
     }
 });
-router.post('/api/agents/:agentId/generate', async ({ params, json, mastra }) => {
+router.post('/api/agents/:agentId/generate', async ({ params, json }) => {
     try {
         const agentId = decodeURIComponent(params.agentId);
         const agent = mastra.getAgent(agentId);
@@ -152,7 +144,7 @@ router.post('/api/agents/:agentId/generate', async ({ params, json, mastra }) =>
         });
     }
 });
-router.post('/api/agents/:agentId/stream', async ({ params, json, mastra }) => {
+router.post('/api/agents/:agentId/stream', async ({ params, json }) => {
     try {
         const agentId = decodeURIComponent(params.agentId);
         const agent = mastra.getAgent(agentId);
@@ -194,7 +186,7 @@ router.post('/api/agents/:agentId/stream', async ({ params, json, mastra }) => {
         });
     }
 });
-router.post('/api/agents/:agentId/text-object', async ({ params, json, mastra }) => {
+router.post('/api/agents/:agentId/text-object', async ({ params, json }) => {
     try {
         const agentId = decodeURIComponent(params.agentId);
         const agent = mastra.getAgent(agentId);
@@ -237,7 +229,7 @@ router.post('/api/agents/:agentId/text-object', async ({ params, json, mastra })
         });
     }
 });
-router.post('/api/agents/:agentId/stream-object', async ({ params, json, mastra }) => {
+router.post('/api/agents/:agentId/stream-object', async ({ params, json }) => {
     try {
         const agentId = decodeURIComponent(params.agentId);
         const agent = mastra.getAgent(agentId);
@@ -282,7 +274,7 @@ router.post('/api/agents/:agentId/stream-object', async ({ params, json, mastra
         });
     }
 });
-router.post('/api/agents/:agentId/tools/:toolId/execute', async ({ params, json, mastra }) => {
+router.post('/api/agents/:agentId/tools/:toolId/execute', async ({ params, json }) => {
     try {
         const agentId = decodeURIComponent(params.agentId);
         const toolId = decodeURIComponent(params.toolId);
@@ -313,7 +305,7 @@ router.post('/api/agents/:agentId/tools/:toolId/execute', async ({ params, json,
         });
     }
 });
-router.get('/api/workflows', async ({ mastra }) => {
+router.get('/api/workflows', async () => {
     try {
         const workflows = mastra.getWorkflows({ serialized: true });
         return new Response(JSON.stringify(workflows), {
@@ -333,7 +325,7 @@ router.get('/api/workflows', async ({ mastra }) => {
         });
     }
 });
-router.get('/api/workflows/:workflowId', async ({ params, mastra }) => {
+router.get('/api/workflows/:workflowId', async ({ params }) => {
     try {
         const workflowId = decodeURIComponent(params.workflowId);
         const workflow = mastra.getWorkflow(workflowId);
@@ -372,7 +364,7 @@ router.get('/api/workflows/:workflowId', async ({ params, mastra }) => {
         });
     }
 });
-router.post('/workflows/:workflowId/execute', async ({ params, json, mastra }) => {
+router.post('/workflows/:workflowId/execute', async ({ params, json }) => {
     try {
         const workflowId = decodeURIComponent(params.workflowId);
         const workflow = mastra.getWorkflow(workflowId);
@@ -395,7 +387,7 @@ router.post('/workflows/:workflowId/execute', async ({ params, json, mastra }) =
         });
     }
 });
-router.get('/api/memory/status', async ({ mastra }) => {
+router.get('/api/memory/status', async () => {
     try {
         const memory = mastra.memory;
         if (!memory) {
@@ -422,7 +414,7 @@ router.get('/api/memory/status', async ({ mastra }) => {
         });
     }
 });
-router.get('/api/memory/threads', async ({ query, mastra }) => {
+router.get('/api/memory/threads', async ({ query }) => {
     try {
         const { resourceid } = query;
         const memory = mastra.memory;
@@ -452,7 +444,7 @@ router.get('/api/memory/threads', async ({ query, mastra }) => {
         });
     }
 });
-router.get('/api/memory/threads/:threadId', async ({ params, mastra }) => {
+router.get('/api/memory/threads/:threadId', async ({ params }) => {
     try {
         const threadId = decodeURIComponent(params.threadId);
         const memory = mastra.memory;
@@ -490,7 +482,7 @@ router.get('/api/memory/threads/:threadId', async ({ params, mastra }) => {
         });
     }
 });
-router.post('/api/memory/threads', async ({ json, mastra }) => {
+router.post('/api/memory/threads', async ({ json }) => {
     try {
         const memory = mastra.memory;
         const { title, metadata, resourceid, threadId } = await json();
@@ -529,7 +521,7 @@ router.post('/api/memory/threads', async ({ json, mastra }) => {
         });
     }
 });
-router.patch('/api/memory/threads/:threadId', async ({ params, json, mastra }) => {
+router.patch('/api/memory/threads/:threadId', async ({ params, json }) => {
     try {
         const threadId = decodeURIComponent(params.threadId);
         const memory = mastra.memory;
@@ -578,7 +570,7 @@ router.patch('/api/memory/threads/:threadId', async ({ params, json, mastra }) =
         });
     }
 });
-router.delete('/api/memory/threads/:threadId', async ({ params, mastra }) => {
+router.delete('/api/memory/threads/:threadId', async ({ params }) => {
     try {
         const threadId = decodeURIComponent(params.threadId);
         const memory = mastra.memory;
@@ -617,7 +609,7 @@ router.delete('/api/memory/threads/:threadId', async ({ params, mastra }) => {
         });
     }
 });
-router.get('/api/memory/threads/:threadId/messages', async ({ params, mastra }) => {
+router.get('/api/memory/threads/:threadId/messages', async ({ params }) => {
     try {
         const threadId = decodeURIComponent(params.threadId);
         const memory = mastra.memory;
@@ -656,7 +648,7 @@ router.get('/api/memory/threads/:threadId/messages', async ({ params, mastra })
         });
     }
 });
-router.get('/api/memory/threads/:threadId/context-window', async ({ params, query, mastra }) => {
+router.get('/api/memory/threads/:threadId/context-window', async ({ params, query }) => {
     try {
         const threadId = decodeURIComponent(params.threadId);
         const { startDate, endDate, format } = query;
@@ -696,7 +688,7 @@ router.get('/api/memory/threads/:threadId/context-window', async ({ params, quer
         });
     }
 });
-router.post('/api/memory/save-messages', async ({ json, mastra }) => {
+router.post('/api/memory/save-messages', async ({ json }) => {
     try {
         const memory = mastra.memory;
         const { messages } = await json();
@@ -750,7 +742,7 @@ router.post('/api/memory/save-messages', async ({ json, mastra }) => {
         });
     }
 });
-router.post('/api/memory/threads/:threadId/tool-result', async ({ params, json, mastra }) => {
+router.post('/api/memory/threads/:threadId/tool-result', async ({ params, json }) => {
     try {
         const threadId = decodeURIComponent(params.threadId);
         const memory = mastra.memory;
@@ -799,7 +791,7 @@ router.post('/api/memory/threads/:threadId/tool-result', async ({ params, json,
         });
     }
 });
-router.post('/api/memory/validate-tool-call-args', async ({ json, mastra }) => {
+router.post('/api/memory/validate-tool-call-args', async ({ json }) => {
     try {
         const memory = mastra.memory;
         const { hashedArgs } = await json();
@@ -838,7 +830,7 @@ router.post('/api/memory/validate-tool-call-args', async ({ json, mastra }) => {
         });
     }
 });
-router.post('/api/syncs/:syncId/execute', async ({ params, json, mastra }) => {
+router.post('/api/syncs/:syncId/execute', async ({ params, json }) => {
     try {
         const syncId = decodeURIComponent(params.syncId);
         const { runId, params: syncParams } = await json();
@@ -869,7 +861,7 @@ router.post('/api/syncs/:syncId/execute', async ({ params, json, mastra }) => {
         });
     }
 });
-router.get('/api/logs', async ({ mastra }) => {
+router.get('/api/logs', async () => {
     try {
         const logs = await mastra.getLogs();
         return new Response(JSON.stringify(logs), {
@@ -889,7 +881,7 @@ router.get('/api/logs', async ({ mastra }) => {
         });
     }
 });
-router.get('/api/logs/:runId', async ({ params, mastra }) => {
+router.get('/api/logs/:runId', async ({ params }) => {
     try {
         const runId = decodeURIComponent(params.runId);
         const logs = await mastra.getLogsByRunId(runId);
@@ -959,7 +951,7 @@ router.get('/api/tools/:toolId', async ({ params }) => {
         });
     }
 });
-router.post('/api/tools/:toolId/execute', async ({ params, json, mastra }) => {
+router.post('/api/tools/:toolId/execute', async ({ params, json }) => {
     try {
         const toolId = decodeURIComponent(params.toolId);
         const tool = Object.values(tools || {}).find((tool) => tool.id === toolId);

package/dist/utils/bundle.d.ts

@@ -25,10 +25,29 @@ export declare function bundleServer(entryPoint: string): Promise<esbuild.BuildR
         setup(build: any): void;
     }[];
 }>>;
-export declare function bundle(dirPath: string, { useBanner, ...options }?: {
+export declare function bundle(dirPath: string, options?: {
     outfile?: string;
     entryFile?: string;
     buildName?: string;
-    useBanner?: boolean;
-}): Promise<esbuild.BuildResult<esbuild.BuildOptions>>;
+}): Promise<esbuild.BuildResult<{
+    entryPoints: string[];
+    bundle: true;
+    platform: "node";
+    format: "esm";
+    outfile: string;
+    target: string;
+    sourcemap: true;
+    minify: true;
+    metafile: true;
+    logLevel: "error";
+    mainFields: string[];
+    conditions: string[];
+    banner: {
+        js: string;
+    };
+    logOverride: {
+        'commonjs-variable-in-esm': "silent";
+    };
+    external: string[];
+}>>;
 //# sourceMappingURL=bundle.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/utils/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAcnC,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;qBAYlC,GAAG;;IAyGrB;AAED,wBAAsB,MAAM,CAC1B,OAAO,EAAE,MAAM,EACf,EACE,SAAgB,EAChB,GAAG,OAAO,EACX,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,sDA8G1F"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/utils/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAanC,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;qBAYlC,GAAG;;IA4GrB;AAED,wBAAsB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;IAuGnH"}

package/dist/utils/bundle.js

@@ -20,12 +20,19 @@ export async function bundleServer(entryPoint) {
                 build.onResolve({ filter: /^.*$/ }, (args) => {
                     if (!args.importer.endsWith('.mastra/index.mjs'))
                         return;
+                    console.log(args.importer, args.path, { import: import.meta.resolve(args.path) });
+                    if (!args.path.startsWith('.'))
+                        return;
                     try {
+                        console.log('Resolving', args.path, { import: import.meta.resolve(args.path) });
                         const resolvedPath = import.meta.resolve(args.path);
-                        if (!resolvedPath || resolvedPath.includes('_npx/')) {
+                        if (!resolvedPath) {
                             missingMastraDependency = true;
                             return { path: args.path, external: true };
                         }
+                        else {
+                            return { path: resolvedPath, external: false };
+                        }
                     }
                     catch (e) {
                         missingMastraDependency = true;
@@ -100,7 +107,7 @@ export async function bundleServer(entryPoint) {
             plugins: [externalIfMissingPlugin],
         });
         if (missingMastraDependency) {
-            console.error(`Missing Mastra dependency. Please install the mastra package in your project or globally using npm i -g mastra`);
+            console.error('Missing Mastra dependency. Please install it using `npm i -g mastra`');
             process.exit(1);
         }
         // Output build metadata
@@ -119,14 +126,14 @@ export async function bundleServer(entryPoint) {
         process.exit(1);
     }
 }
-export async function bundle(dirPath, { useBanner = true, ...options } = {}) {
+export async function bundle(dirPath, options) {
     try {
         // Ensure .mastra directory exists
         upsertMastraDir();
         const fileService = new FileService();
         const entryPoint = fileService.getFirstExistingFile([join(dirPath, `${options?.entryFile || 'index'}.ts`)]);
         const outfile = options?.outfile || join(process.cwd(), '.mastra', 'mastra.mjs');
-        const esbuildConfig = {
+        const result = await esbuild.build({
             entryPoints: [entryPoint],
             bundle: true,
             platform: 'node',
@@ -139,6 +146,16 @@ export async function bundle(dirPath, { useBanner = true, ...options } = {}) {
             logLevel: 'error',
             mainFields: ['module', 'main'],
             conditions: ['import', 'node'],
+            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',
             },
@@ -190,21 +207,7 @@ export async function bundle(dirPath, { useBanner = true, ...options } = {}) {
                 '@mastra/rag',
                 '@mastra/stabilityai',
             ],
-        };
-        if (useBanner) {
-            esbuildConfig.banner = {
-                js: `
-          import { createRequire } from "module";
-          import { fileURLToPath, pathToFileURL } from 'url';
-          import path from 'path';
-
-          const __filename = fileURLToPath(import.meta.url);
-          const __dirname = path.dirname(__filename);
-          const require = createRequire(import.meta.url);
-        `,
-            };
-        }
-        const result = await esbuild.build(esbuildConfig);
+        });
         // Log build results
         logger.success(`${options?.buildName} Build completed successfully`);
         // Output build metadata

package/dist/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/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/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/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/utils/get-first-existing-file.d.ts

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

package/dist/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/utils/get-package-manager.d.ts

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

package/dist/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/utils/get-package-version.d.ts

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

package/dist/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/utils/get-project-name.d.ts

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

package/dist/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/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/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/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/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/utils/sanitize-docker-name.d.ts

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

package/dist/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/utils/setup-docker-compose.d.ts

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

package/dist/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/utils/setup-env-file.d.ts

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

package/dist/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);
+}