mastra-starter 1.0.9 → 1.0.10

package/chad.character.json

@@ -8,7 +8,10 @@
       "model": "en_US-male-medium"
     }
   },
-  "plugins": ["github:qpd-v/mcp-communicator-telegram"],
+  "plugins": [
+    "github:v-3/discordmcp",
+    "github:qpd-v/mcp-communicator-telegram"
+  ],
   "bio": [
     "Just a chill guy living life to the fullest",
     "Always down to help others out",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mastra-starter",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "main": "index.mjs",
   "bin": {
     "mastra-starter": "./index.mjs"
@@ -15,13 +15,13 @@
   "type": "module",
   "dependencies": {
     "@ai-sdk/openai": "^1.2.2",
-    "@mastra/composio": "^0.1.9",
-    "@mastra/core": "^0.6.0",
-    "@mastra/mcp": "^0.3.0",
+    "@mastra/composio": "^0.1.12",
+    "@mastra/core": "^0.6.3",
+    "@mastra/mcp": "^0.3.4",
     "commander": "^13.1.0",
     "dedent": "^1.5.3",
     "dotenv": "^16.4.7",
-    "mastra": "^0.3.0",
+    "mastra": "^0.3.1",
     "mkdirp": "^3.0.1",
     "pnpm-package-lookup": "^0.0.2",
     "rimraf": "^6.0.1",

package/src/mastra/agents/index.ts

@@ -3,7 +3,7 @@ import path from "path";
 import { createOpenAI } from "@ai-sdk/openai";
 import { Agent, ToolsInput } from "@mastra/core/agent";
 import dedent from "dedent";
-import { PnpmPackageLookup } from 'pnpm-package-lookup';
+import { PnpmPackageLookup } from "pnpm-package-lookup";
 import { MCPConfiguration } from "@mastra/mcp";
 import { ComposioIntegration } from "@mastra/composio";
 import { sortPlugins, getNpmPackageType } from "../../../util.mjs";
@@ -33,31 +33,44 @@ for (const pluginSpecifier of npmPlugins) {
   let pluginSpecifier2;
   const packagesDir = path.resolve(rootDir, "packages");
   if (npmPackageType === "github") {
-    const packageBasename = path.basename(pluginSpecifier.replace("github:", ""));
+    const packageBasename = path.basename(
+      pluginSpecifier.replace("github:", "")
+    );
     const packageResolvedName = `file:${path.resolve(packagesDir, packageBasename)}`;
-    pluginSpecifier2 = await pnpmPackageLookup.getPackageNameBySpecifier(packageResolvedName);
+    pluginSpecifier2 =
+      await pnpmPackageLookup.getPackageNameBySpecifier(packageResolvedName);
     if (!pluginSpecifier2) {
-      throw new Error(`Could not resolve package name for ${JSON.stringify({
-        pluginSpecifier,
-        packageBasename,
-        packageResolvedName,
-      }, null, 2)}`);
+      throw new Error(
+        `Could not resolve package name for ${JSON.stringify(
+          {
+            pluginSpecifier,
+            packageBasename,
+            packageResolvedName,
+          },
+          null,
+          2
+        )}`
+      );
     }
   } else {
     pluginSpecifier2 = pluginSpecifier;
   }
   const packagePath = path.resolve(rootDir, "node_modules", pluginSpecifier2);
-  // console.log('packagePath', {
-  //   pluginSpecifier,
-  //   pluginSpecifier2,
-  //   packagePath,
-  // });
-
   // check if start script exists
   const packageJsonPath = path.resolve(packagePath, "package.json");
-  const packageJson = JSON.parse(await fs.promises.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(
+    await fs.promises.readFile(packageJsonPath, "utf8")
+  );
+  const pluginName =
+    pluginSpecifier
+      // .replace(/^github:/, "")
+      .replace(/[\/:]+/g, "-")
+      .replace(/[^a-zA-Z0-9_-]/g, "");
+  if (!pluginName) {
+    throw new Error(`Could not clean up plugin name for ${pluginSpecifier}`);
+  }
   if (packageJson.scripts.start) {
-    servers[pluginSpecifier] = {
+    servers[pluginName] = {
       command: "pnpm",
       args: ["--dir", packagePath, "--silent", "start"],
       env: process.env as any,
@@ -66,17 +79,18 @@ for (const pluginSpecifier of npmPlugins) {
     // check if any bins exist; if so, use the first one
     if (packageJson.bin && Object.keys(packageJson.bin).length > 0) {
       const firstBin = Object.keys(packageJson.bin)[0];
-      servers[pluginSpecifier] = {
+      servers[pluginName] = {
         command: "pnpm",
         args: ["--dir", packagePath, "--silent", "exec", firstBin],
         env: process.env as any,
       };
     } else {
-      throw new Error(`No start script or bins found for ${pluginSpecifier}`);
+      throw new Error(
+        `No start script or bins found for ${pluginSpecifier} name ${pluginName}`
+      );
     }
   }
 }
-// console.log('servers', servers);
 
 // mcp tools
 const mcp = new MCPConfiguration({

package/util.mjs

@@ -81,8 +81,11 @@ export const sortNpmPackages = (packageSpecifiers) => {
 const installNpmGithubPackages = async (packageSpecifiers) => {
   console.log(`Installing github packages: ${packageSpecifiers.join(", ")}`);
 
-  // Ensure packages directory exists
+  // wipe packages directory
   const packagesDir = path.resolve(process.cwd(), "packages");
+  await rimraf(packagesDir);
+
+  // Ensure packages directory exists
   try {
     await mkdirp(packagesDir);
   } catch (error) {
@@ -90,130 +93,151 @@ const installNpmGithubPackages = async (packageSpecifiers) => {
     return Promise.reject(error);
   }
 
-  // remove conflicting package directories
-  const existingPackageNames = await fs.promises.readdir(packagesDir);
-  for (const packageName of existingPackageNames) {
-    const packagePath = path.resolve(packagesDir, packageName);
-    await rimraf(packagePath);
-  }
+  // Transform package specifiers to GitHub URLs
+  const repoNames = packageSpecifiers.map((specifier) => {
+    specifier = specifier.replace("github:", "");
+    specifier = `https://github.com/${specifier}`;
+    return specifier;
+  });
 
   // git clone all packages
-  await new Promise((resolve, reject) => {
-    const repoNames = packageSpecifiers.map((specifier) => {
-      specifier = specifier.replace("github:", "");
-      specifier = `https://github.com/${specifier}`;
-      return specifier;
-    });
-    const cp = child_process.spawn(
-      "git",
-      ["clone", "--depth", "1", ...repoNames],
-      {
-        stdio: "inherit",
-        cwd: packagesDir,
-      }
-    );
-
-    cp.on("error", (error) => {
-      console.error(`Error executing git clone: ${error.stack}`);
-      reject(error);
-    });
-
-    cp.on("close", (code) => {
-      if (code !== 0) {
-        console.error(`git clone exited with code ${code}`);
-        reject(new Error(`git clone exited with code ${code}`));
-      } else {
-        resolve();
-      }
-    });
-  });
+  await Promise.all(
+    repoNames.map(async (repoUrl) => {
+      return new Promise((resolveClone, rejectClone) => {
+        console.log(`Cloning ${repoUrl}...`);
+        const cp = child_process.spawn(
+          "git",
+          ["clone", "--depth", "1", repoUrl],
+          {
+            stdio: "inherit",
+            cwd: packagesDir,
+          }
+        );
 
-  // pnpm install in local directory
-  await Promise.all(packageSpecifiers.map(async (packageSpecifier) => {
-    const packageBasename = path.basename(packageSpecifier.replace("github:", ""));
-    const packagePath = path.resolve(packagesDir, packageBasename);
+        cp.on("error", (error) => {
+          console.error(
+            `Error executing git clone for ${repoUrl}: ${error.stack}`
+          );
+          rejectClone(error);
+        });
 
-    await new Promise((resolveInstall, rejectInstall) => {
-      const cp = child_process.spawn("pnpm", ["install"], {
-        stdio: "inherit",
-        cwd: packagePath,
-        env: { ...process.env },
+        cp.on("close", (code) => {
+          if (code !== 0) {
+            console.error(`git clone for ${repoUrl} exited with code ${code}`);
+            rejectClone(new Error(`git clone exited with code ${code}`));
+          } else {
+            console.log(`Successfully cloned ${repoUrl}`);
+            resolveClone();
+          }
+        });
       });
+    })
+  );
 
-      cp.on("error", (error) => {
-        console.error(
-          `Error executing pnpm install for ${packageBasename}: ${error.stack}`
-        );
-        rejectInstall(error);
-      });
-      cp.on("close", (code) => {
-        if (code !== 0) {
-          rejectInstall(new Error(`pnpm install exited with code ${code}`));
-        } else {
-          resolveInstall();
-        }
-      });
-    });
+  // build and install all plugins into local packages
+  await Promise.all(
+    packageSpecifiers.map(async (packageSpecifier) => {
+      const packageBasename = path.basename(
+        packageSpecifier.replace("github:", "")
+      );
+      const packagePath = path.resolve(packagesDir, packageBasename);
+      
+      // pnpm install in local directory
+      await new Promise((resolveInstall, rejectInstall) => {
+        const cp = child_process.spawn("pnpm", ["install"], {
+          stdio: "inherit",
+          cwd: packagePath,
+          env: { ...process.env },
+        });
 
-    // pnpm build
-    // note: this is advisory and allowed to fail
-    await new Promise((resolveSpawn, rejectSpawn) => {
-      const cp = child_process.spawn("pnpm", ["build"], {
-        stdio: "inherit",
-        cwd: packagePath,
-        env: { ...process.env },
+        cp.on("error", (error) => {
+          console.error(
+            `Error executing pnpm install for ${packageBasename}: ${error.stack}`
+          );
+          rejectInstall(error);
+        });
+        cp.on("close", (code) => {
+          if (code !== 0) {
+            rejectInstall(new Error(`pnpm install exited with code ${code}`));
+          } else {
+            resolveInstall();
+          }
+        });
       });
 
-      cp.on("error", (error) => {
-        console.error(
-          `Error executing pnpm build for ${packageBasename}: ${error.stack}`
-        );
-        resolveSpawn({
-          success: false,
-          package: packageBasename,
-          error: error.stack,
+      // pnpm build
+      // note: this is advisory and allowed to fail
+      await new Promise((resolveSpawn, rejectSpawn) => {
+        const cp = child_process.spawn("pnpm", ["build"], {
+          stdio: "inherit",
+          cwd: packagePath,
+          env: { ...process.env },
         });
-      });
-      cp.on("close", (code) => {
-        if (code !== 0) {
+
+        cp.on("error", (error) => {
           console.error(
-            `pnpm build for ${packageBasename} exited with code ${code}`
+            `Error executing pnpm build for ${packageBasename}: ${error.stack}`
           );
           resolveSpawn({
             success: false,
             package: packageBasename,
-            error: `exited with code ${code}`,
+            error: error.stack,
           });
-        } else {
-          console.log(`Build completed successfully for ${packageBasename}`);
-          resolveSpawn({ success: true, package: packageBasename });
-        }
+        });
+        cp.on("close", (code) => {
+          if (code !== 0) {
+            console.error(
+              `pnpm build for ${packageBasename} exited with code ${code}`
+            );
+            resolveSpawn({
+              success: false,
+              package: packageBasename,
+              error: `exited with code ${code}`,
+            });
+          } else {
+            console.log(`Build completed successfully for ${packageBasename}`);
+            resolveSpawn({ success: true, package: packageBasename });
+          }
+        });
       });
-    });
+    })
+  );
 
-    // pnpm install to app
-    await new Promise((resolveInstall, rejectInstall) => {
-      const cp = child_process.spawn("pnpm", ["install", `file:${packagePath}`], {
+  // install all plugins into app
+  // pnpm install to app
+  await new Promise((resolveInstall, rejectInstall) => {
+    const packageRefs = packageSpecifiers.map((packageSpecifier) => {
+      const packageBasename = path.basename(
+        packageSpecifier.replace("github:", "")
+      );
+      const packagePath = path.resolve(packagesDir, packageBasename);
+      return `file:${packagePath}`;
+    });
+    console.log(`Installing ${JSON.stringify(packageRefs)} to app`);
+    const cp = child_process.spawn(
+      "pnpm",
+      ["install", ...packageRefs],
+      {
         stdio: "inherit",
         cwd: process.cwd(),
         env: { ...process.env },
-      });
+      }
+    );
 
-      cp.on("error", (error) => {
-        console.error(
-          `Error executing pnpm install for ${packageBasename}: ${error.stack}`
-        );
-        rejectInstall(error);
-      });
-      cp.on("close", (code) => {
-        if (code !== 0) {
-          rejectInstall(new Error(`pnpm install exited with code ${code}`));
-        } else {
-          resolveInstall();
-        }
-      });
+    cp.on("error", (error) => {
+      console.error(
+        `Error executing pnpm install for ${packageBasename}: ${error.stack}`
+      );
+      rejectInstall(error);
+    });
+    cp.on("close", (code) => {
+      if (code !== 0) {
+        rejectInstall(new Error(`pnpm install exited with code ${code}`));
+      } else {
+        resolveInstall();
+      }
     });
-  }));
+  });
 };
 const installNpmBasicPackages = async (packageSpecifiers) => {
   // packageSpecifiers = uniquify(packageSpecifiers);
@@ -244,6 +268,6 @@ export const installNpmPackages = async (packageSpecifiers) => {
   const { github, npm } = sortNpmPackages(packageSpecifiers);
   await Promise.all([
     installNpmGithubPackages(github),
-    installNpmBasicPackages(npm)
+    installNpmBasicPackages(npm),
   ]);
-};
+};

package/src/mastra/agents/util.ts

@@ -1,23 +0,0 @@
-export const getPluginType = (plugin: string) => {
-  if (plugin.startsWith('composio:')) {
-    return 'composio';
-  } else {
-    return 'npm';
-  }
-};
-export const sortPlugins = (plugins: string[]) => {
-  const npm: string[] = [];
-  const composio: string[] = [];
-  for (const plugin of plugins) {
-    const pluginType = getPluginType(plugin);
-    if (pluginType === 'npm') {
-      npm.push(plugin);
-    } else if (pluginType === 'composio') {
-      composio.push(plugin);
-    }
-  }
-  return {
-    npm,
-    composio,
-  };
-};

package/src/mastra/tools/index.ts

@@ -1,102 +0,0 @@
-import { createTool } from '@mastra/core/tools';
-import { z } from 'zod';
-
-interface GeocodingResponse {
-  results: {
-    latitude: number;
-    longitude: number;
-    name: string;
-  }[];
-}
-interface WeatherResponse {
-  current: {
-    time: string;
-    temperature_2m: number;
-    apparent_temperature: number;
-    relative_humidity_2m: number;
-    wind_speed_10m: number;
-    wind_gusts_10m: number;
-    weather_code: number;
-  };
-}
-
-export const weatherTool = createTool({
-  id: 'get-weather',
-  description: 'Get current weather for a location',
-  inputSchema: z.object({
-    location: z.string().describe('City name'),
-  }),
-  outputSchema: z.object({
-    temperature: z.number(),
-    feelsLike: z.number(),
-    humidity: z.number(),
-    windSpeed: z.number(),
-    windGust: z.number(),
-    conditions: z.string(),
-    location: z.string(),
-  }),
-  execute: async ({ context }) => {
-    return await getWeather(context.location);
-  },
-});
-
-const getWeather = async (location: string) => {
-  const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
-  const geocodingResponse = await fetch(geocodingUrl);
-  const geocodingData = (await geocodingResponse.json()) as GeocodingResponse;
-
-  if (!geocodingData.results?.[0]) {
-    throw new Error(`Location '${location}' not found`);
-  }
-
-  const { latitude, longitude, name } = geocodingData.results[0];
-
-  const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,wind_gusts_10m,weather_code`;
-
-  const response = await fetch(weatherUrl);
-  const data = (await response.json()) as WeatherResponse;
-
-  return {
-    temperature: data.current.temperature_2m,
-    feelsLike: data.current.apparent_temperature,
-    humidity: data.current.relative_humidity_2m,
-    windSpeed: data.current.wind_speed_10m,
-    windGust: data.current.wind_gusts_10m,
-    conditions: getWeatherCondition(data.current.weather_code),
-    location: name,
-  };
-};
-
-function getWeatherCondition(code: number): string {
-  const conditions: Record<number, string> = {
-    0: 'Clear sky',
-    1: 'Mainly clear',
-    2: 'Partly cloudy',
-    3: 'Overcast',
-    45: 'Foggy',
-    48: 'Depositing rime fog',
-    51: 'Light drizzle',
-    53: 'Moderate drizzle',
-    55: 'Dense drizzle',
-    56: 'Light freezing drizzle',
-    57: 'Dense freezing drizzle',
-    61: 'Slight rain',
-    63: 'Moderate rain',
-    65: 'Heavy rain',
-    66: 'Light freezing rain',
-    67: 'Heavy freezing rain',
-    71: 'Slight snow fall',
-    73: 'Moderate snow fall',
-    75: 'Heavy snow fall',
-    77: 'Snow grains',
-    80: 'Slight rain showers',
-    81: 'Moderate rain showers',
-    82: 'Violent rain showers',
-    85: 'Slight snow showers',
-    86: 'Heavy snow showers',
-    95: 'Thunderstorm',
-    96: 'Thunderstorm with slight hail',
-    99: 'Thunderstorm with heavy hail',
-  };
-  return conditions[code] || 'Unknown';
-}

package/util.d.ts

@@ -1 +0,0 @@
-declare module "util.mjs";