@isolo/trinity 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isolo/trinity",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A Bun-based MCP server framework with dynamic tool loading, hot reload, and stdio/HTTP modes",
   "type": "module",
   "license": "MIT",

package/src/Config.ts

@@ -1,4 +1,5 @@
 import path from "node:path";
+import fs from "node:fs";
 
 export class Config {
   private static instance: Config | null = null;
@@ -50,13 +51,18 @@ export class Config {
 
     if (!this._targetFolder) {
       throw new Error(
-        "Missing required argument: --target <path>. Specify the folder containing tool files."
+        "Missing required argument: --target <path>. Specify the folder containing tool files.",
       );
     }
 
     // Resolve to absolute path
     this._targetFolder = path.resolve(this._targetFolder);
 
+    // Create target folder if it doesn't exist
+    if (!fs.existsSync(this._targetFolder)) {
+      fs.mkdirSync(this._targetFolder, { recursive: true });
+    }
+
     // Default log file relative to target folder
     if (!this._logFile) {
       this._logFile = path.join(this._targetFolder, "debug.log");

package/src/Tools.ts

@@ -27,7 +27,7 @@ export class Tools {
 
   private constructor(
     private logger = new Logger(Tools),
-    private config = Config.getInstance()
+    private config = Config.getInstance(),
   ) {}
 
   async loadTools(): Promise<ToolDefinition[]> {
@@ -40,8 +40,10 @@ export class Tools {
       try {
         const tool = await this.loadToolFromFile(filePath);
         tools.push(tool);
-      } catch (err) {
-        this.logger.error(`Failed to load tool from ${filePath}`, err as Error);
+      } catch (err: any) {
+        this.logger.error(`Failed to load tool from ${filePath}`, {
+          err: err.message,
+        });
       }
     }
 
@@ -51,7 +53,7 @@ export class Tools {
   async loadTool(name: string): Promise<ToolDefinition> {
     const files = await this.resolveToolFiles();
     const filePath = files.find(
-      (f) => path.basename(f, path.extname(f)) === name
+      (f) => path.basename(f, path.extname(f)) === name,
     );
 
     if (!filePath) {
@@ -76,7 +78,7 @@ export class Tools {
         if (filename) {
           this.onFileChange(event, filename);
         }
-      }
+      },
     );
 
     this.watcher.on("error", (err: Error) => {
@@ -110,19 +112,19 @@ export class Tools {
 
     if (!mod.description || typeof mod.description !== "string") {
       throw new Error(
-        `Tool file ${filePath} must export a 'description' string`
+        `Tool file ${filePath} must export a 'description' string`,
       );
     }
 
     if (!mod.inputSchema || typeof mod.inputSchema !== "object") {
       throw new Error(
-        `Tool file ${filePath} must export an 'inputSchema' object`
+        `Tool file ${filePath} must export an 'inputSchema' object`,
       );
     }
 
     if (!mod.default || typeof mod.default !== "function") {
       throw new Error(
-        `Tool file ${filePath} must have a default export function (execute)`
+        `Tool file ${filePath} must have a default export function (execute)`,
       );
     }
 
@@ -134,9 +136,20 @@ export class Tools {
     };
   }
 
-  private async dynamicImport(filePath: string): Promise<Record<string, unknown>> {
-    // Cache-busting with timestamp to always get fresh module
-    return import(`${filePath}?t=${Date.now()}`);
+  private async dynamicImport(
+    filePath: string,
+  ): Promise<Record<string, unknown>> {
+    try {
+      // Cache-busting with timestamp to always get fresh module
+      return import(`${filePath}?t=${Date.now()}`);
+    } catch (err) {
+      this.logger.error(`Failed to import tool module`, {
+        err: (err as Error).message,
+        filePath,
+      });
+
+      throw err;
+    }
   }
 
   private buildDescription(description: string, filePath: string): string {