mastra-starter 1.0.5 → 1.0.6

package/.env.example

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=
+COMPOSIO_API_KEY=

package/index.mjs

@@ -6,7 +6,7 @@ import fs from 'fs';
 import { Command } from 'commander';
 import dotenv from 'dotenv';
 
-import { runCharacter, installPackages } from './util.mjs';
+import { runCharacter, installPackages, buildPackages } from './util.mjs';
 
 const main = async () => {
   dotenv.config();
@@ -43,6 +43,7 @@ const main = async () => {
     .action(async (packages) => {
       try {
         await installPackages(packages);
+        await buildPackages(packages);
       } catch (error) {
         console.error(`Error in install command: ${error.message}`);
       }
@@ -74,12 +75,58 @@ const main = async () => {
         }
         
         await installPackages([...pluginsToInstall]);
+        await buildPackages([...pluginsToInstall]);
       } catch (error) {
         console.error(`Error in installall command: ${error.message}`);
       }
       process.exit(1);
     });
 
+  program
+    .command('build')
+    .alias('b')
+    .description('Build packages without installing them')
+    .argument('<packages...>', 'packages to build')
+    .action(async (packages) => {
+      try {
+        await buildPackages(packages);
+      } catch (error) {
+        console.error(`Error in build command: ${error.message}`);
+      }
+      process.exit(1);
+    });
+
+  program
+    .command('buildall')
+    .alias('ba')
+    .description('Build all plugins from character.json files')
+    .argument('<files...>', 'character.json file paths')
+    .action(async (files) => {
+      try {
+        const pluginsToBuild = new Set();
+        
+        for (const file of files) {
+          const characterJsonPath = path.resolve(process.cwd(), file);
+          const characterJsonString = await fs.promises.readFile(characterJsonPath, 'utf8');
+          const characterJson = JSON.parse(characterJsonString);
+          
+          if (characterJson.plugins && Array.isArray(characterJson.plugins)) {
+            characterJson.plugins.forEach(plugin => pluginsToBuild.add(plugin));
+          }
+        }
+        
+        if (pluginsToBuild.size === 0) {
+          console.log('No plugins found to build');
+          return;
+        }
+        
+        await buildPackages([...pluginsToBuild]);
+      } catch (error) {
+        console.error(`Error in buildall command: ${error.message}`);
+      }
+      process.exit(1);
+    });
+
   program.parse(process.argv);
 };
 (async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mastra-starter",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "main": "index.mjs",
   "bin": {
     "mastra-starter": "./index.mjs"
@@ -15,13 +15,14 @@
   "type": "module",
   "dependencies": {
     "@ai-sdk/openai": "^1.2.2",
+    "@mastra/composio": "^0.1.9",
     "@mastra/core": "^0.5.0",
     "@mastra/mcp": "^0.3.0",
     "commander": "^13.1.0",
     "dedent": "^1.5.3",
     "dotenv": "^16.4.7",
     "mastra": "^0.3.0",
-    "pnpm-package-lookup": "^0.0.1",
+    "pnpm-package-lookup": "^0.0.2",
     "yaml": "^2.7.0",
     "zod": "^3.24.2"
   },

package/src/mastra/agents/index.ts

@@ -1,22 +1,35 @@
 import fs from 'fs';
 import path from 'path';
 import { openai } from '@ai-sdk/openai';
-import { Agent } from '@mastra/core/agent';
+import { Agent, ToolsInput } from '@mastra/core/agent';
 import dedent from 'dedent';
 import { MCPConfiguration } from "@mastra/mcp";
+import { ComposioIntegration } from '@mastra/composio';
 import { PnpmPackageLookup } from 'pnpm-package-lookup';
 
+// character
 const packageLookup = new PnpmPackageLookup({
   pnpmLockYamlPath: path.join('..', '..', 'pnpm-lock.yaml'),
 });
-
 const characterJsonPath = process.env._CHARACTER_JSON_PATH as string;
 const characterJsonString = await fs.promises.readFile(characterJsonPath, 'utf8');
 const characterJson = JSON.parse(characterJsonString);
+
+// sort plugins
 const { plugins = [] } = characterJson;
+const npmPlugins: string[] = [];
+const composioPlugins: string[] = [];
+for (const plugin of plugins) {
+  if (plugin.startsWith('composio:')) {
+    composioPlugins.push(plugin);
+  } else {
+    npmPlugins.push(plugin);
+  }
+}
 
+// resolve npm plugins
 const servers: Record<string, any> = {};
-for (const plugin of plugins) {
+for (const plugin of npmPlugins) {
   // find the package name matching this specifier
   const packageName = await packageLookup.getPackageNameBySpecifier(plugin);
   if (!packageName) {
@@ -30,15 +43,41 @@ for (const plugin of plugins) {
     env: process.env as any,
   };
 }
+
+// mcp tools
 const mcp = new MCPConfiguration({
   servers,
 });
+const mcpTools = await mcp.getTools();
+
+// composio tools
+const composio = new ComposioIntegration({
+  config: {
+    API_KEY: process.env.COMPOSIO_API_KEY!,
+    entityId: 'default',
+    // connectedAccountId: '899144e5-a466-428b-8a00-7c931fb57f9f',
+    connectedAccountId: '4d79004e-320a-4dc9-be1a-1037a6fe9866',
+  },
+});
+// const actionsEnums = [
+//   'GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER',
+//   'GITHUB_ACTIVITY_LIST_STARGAZERS_FOR_REPO',
+//   'GITHUB_GET_OCTOCAT',
+// ];
+const actionsEnums = composioPlugins.map((plugin) => plugin.replace('composio:', ''));
+const composioToolset = await composio.getTools({
+  actions: actionsEnums,
+}) as ToolsInput;
 
+// agent
 export const characterAgent = new Agent({
   name: "Character",
   instructions: dedent`\
     You are the following character:
   ` + '\n' + JSON.stringify(characterJson, null, 2),
   model: openai("gpt-4o"),
-  tools: { ...(await mcp.getTools()) },
+  tools: { // ToolsInput = string -> ToolAction
+    ...mcpTools,
+    ...composioToolset,
+  },
 });

package/util.mjs

@@ -1,4 +1,6 @@
+import path from 'path';
 import child_process from "child_process";
+import { PnpmPackageLookup } from 'pnpm-package-lookup';
 
 export const runCharacter = async (characterJsonPath, {
   env = {},
@@ -27,7 +29,7 @@ export const runCharacter = async (characterJsonPath, {
     });
   });
 };
-export const installPackages = async (packageSpecifiers) => {
+export const installPackages = (packageSpecifiers) => {
   console.log(`Installing packages: ${packageSpecifiers.join(", ")}`);
 
   return new Promise((resolve, reject) => {
@@ -51,3 +53,58 @@ export const installPackages = async (packageSpecifiers) => {
     });
   });
 };
+export const buildPackages = async (packageSpecifiers) => {
+  console.log(`Building packages: ${packageSpecifiers.join(", ")}`);
+
+  // get the packagePaths from the packageSpecifiers
+  const packageLookup = new PnpmPackageLookup({
+    pnpmLockYamlPath: path.resolve(process.cwd(), 'pnpm-lock.yaml'),
+  });
+  const packagePaths = await Promise.all(packageSpecifiers.map(async (packageSpecifier) => {
+    return await packageLookup.getPackageNameBySpecifier(packageSpecifier);
+  }));
+
+  const results = [];
+  let allSuccessful = true;
+
+  for (const packagePath of packagePaths) {
+    console.log(`Building package: ${packagePath}`);
+    
+    try {
+      const p = path.resolve(process.cwd(), 'node_modules', packagePath);
+      const cp = child_process.spawn("pnpm", ["build"], {
+        stdio: "inherit",
+        cwd: p,
+        env: { ...process.env },
+      });
+
+      const result = await new Promise((resolveSpawn, rejectSpawn) => {
+        cp.on("error", (error) => {
+          console.error(`Error executing pnpm build for ${packagePath}: ${error.message}`);
+          resolveSpawn({ success: false, package: packagePath, error: error.message });
+        });
+
+        cp.on("close", (code) => {
+          if (code !== 0) {
+            console.error(`pnpm build for ${packagePath} exited with code ${code}`);
+            resolveSpawn({ success: false, package: packagePath, error: `exited with code ${code}` });
+          } else {
+            console.log(`Build completed successfully for ${packagePath}`);
+            resolveSpawn({ success: true, package: packagePath });
+          }
+        });
+      });
+
+      results.push(result);
+      if (!result.success) {
+        allSuccessful = false;
+      }
+    } catch (error) {
+      console.log('error', error);
+      results.push({ success: false, package: packagePath, error: error.message });
+      allSuccessful = false;
+    }
+  }
+
+  return { success: allSuccessful, results };
+};