correctly propagate errors from normalizeError

Author: chriscarrollsmith

index.ts

@@ -10,7 +10,7 @@ import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprot
 const server = new Server(
   {
     name: "task-manager-server",
-    version: "1.2.0"
+    version: "1.3.0"
   },
   {
     capabilities: {

package-lock.json

@@ -1,6 +1,6 @@
 {
 	"name": "taskqueue-mcp",
-	"version": "1.2.0",
+	"version": "1.3.0",
 	"description": "Task Queue MCP Server",
 	"author": "Christopher C. Smith ([email protected])",
 	"main": "dist/index.js",

package.json

@@ -9,14 +9,13 @@ import {
 import { TaskManager } from "../server/TaskManager.js";
 import { createError, normalizeError } from "../utils/errors.js";
 import { formatCliError } from "./errors.js";
-import fs from "fs/promises";
 
 const program = new Command();
 
 program
   .name("taskqueue")
   .description("CLI for the Task Manager MCP Server")
-  .version("1.2.0")
+  .version("1.3.0")
   .option(
     '-f, --file-path <path>',
     'Specify the path to the tasks JSON file. Overrides TASK_MANAGER_FILE_PATH env var.'
@@ -486,16 +485,17 @@ program
   .option("--model <model>", "LLM model to use", "gpt-4-turbo")
   .option("--provider <provider>", "LLM provider to use (openai, google, or deepseek)", "openai")
   .option("--attachment <file>", "File to attach as context (can be specified multiple times)", collect, [])
-  .action(async (options) => {
+  .action(async (options) => {    
     try {
       console.log(chalk.blue(`Generating project plan from prompt...`));
+      console.log(options.attachment);
 
       // Pass attachment filenames directly to the server
       const response = await taskManager.generateProjectPlan({
         prompt: options.prompt,
         provider: options.provider,
         model: options.model,
-        attachments: options.attachment  // Pass the filenames directly
+        attachments: options.attachment
       });
 
       if ('error' in response) {
@@ -537,17 +537,8 @@ program
         console.log(`\n${data.message}`);
       }
     } catch (err: unknown) {
-      if (err instanceof Error) {
-        // Check for API key related errors and format them appropriately
-        if (err.message.includes('API key') || err.message.includes('authentication') || err.message.includes('unauthorized')) {
-          console.error(chalk.red(`Error: ${err.message}`));
-        } else {
-          console.error(chalk.yellow(`Warning: ${err.message}`));
-        }
-      } else {
         const normalized = normalizeError(err);
-        console.error(chalk.red(formatCliError(normalized)));
-      }
+        console.error(`Error: ${chalk.red(formatCliError(normalized))}`);
       process.exit(1);
     }
   });

src/client/cli.ts

@@ -1,9 +1,28 @@
 import { StandardError } from "../types/index.js";
 /**
- * Formats an error message for CLI output
+ * Formats an error message for CLI output, optionally including relevant details.
  */
-export function formatCliError(error: StandardError, includeDetails: boolean = false): string {
+export function formatCliError(error: StandardError, includeDetails: boolean = true): string {
   const codePrefix = error.message.includes(`[${error.code}]`) ? '' : `[${error.code}] `;
-  const message = `${codePrefix}${error.message}`;
-  return includeDetails && error.details ? `${message}\nDetails: ${JSON.stringify(error.details, null, 2)}` : message;
+  let message = `${codePrefix}${error.message}`;
+
+  if (includeDetails && error.details) {
+    // Prioritize showing nested originalError message if it exists and is different
+    const originalErrorMessage = (error.details as any)?.originalError?.message;
+    if (originalErrorMessage && typeof originalErrorMessage === 'string' && originalErrorMessage !== error.message) {
+      message += `\n  -> Details: ${originalErrorMessage}`;
+    } 
+    // Add a fallback for simpler string details or stringified objects if needed,
+    // but avoid dumping large complex objects unless necessary for debugging.
+    // Example: uncomment if you often have simple string details
+    // else if (typeof error.details === 'string') {
+    //  message += `\n  -> Details: ${error.details}`;
+    // }
+    // Example: uncomment ONLY if you need to see the raw JSON details often
+    // else {
+    //   message += `\nDetails: ${JSON.stringify(error.details, null, 2)}`;
+    // }
+  }
+
+  return message;
 }

src/client/errors.ts

@@ -136,11 +136,16 @@ export class TaskManager {
     const attachmentContents: string[] = [];
     for (const filename of attachments) {
       try {
+        console.log("We are about to try to read the file.")
         const content = await this.fileSystemService.readAttachmentFile(filename);
         attachmentContents.push(content);
       } catch (error) {
         // Propagate file read errors
-        throw error;
+        throw createError(
+          ErrorCode.FileReadError,
+          `Failed to read attachment file: ${filename}`,
+          { originalError: error }
+        );
       }
     }
 
@@ -171,6 +176,7 @@ export class TaskManager {
           `Invalid provider: ${provider}`
         );
     }
+    console.log("set model and provider")
 
     // Define the schema for the LLM's response using jsonSchema helper
     const projectPlanSchema = jsonSchema<ProjectPlanOutput>({
@@ -223,6 +229,7 @@ export class TaskManager {
     } catch (err) {
       // Handle specific AI SDK errors
       if (err instanceof Error) {
+        // Check for specific error names or messages
         if (err.name === 'NoObjectGeneratedError') {
           throw createError(
             ErrorCode.InvalidResponseFormat,
@@ -244,20 +251,33 @@ export class TaskManager {
             { originalError: err }
           );
         }
+        // --- Updated Check for API Key Errors ---
+        // Check by name (more robust) or message content
+        if (err.name === 'LoadAPIKeyError' || err.message.includes('API key is missing')) {
+           throw createError(
+            ErrorCode.ConfigurationError, // Use the correct code for config issues
+            "Invalid or missing API key. Please check your environment variables.", // More specific message
+            { originalError: err }
+          );
+        }
+        // Existing check for general auth errors (might still be relevant for other cases)
         if (err.message.includes('authentication') || err.message.includes('unauthorized')) {
           throw createError(
             ErrorCode.ConfigurationError,
-            "Invalid API key or authentication failed. Please check your environment variables.",
+            "Authentication failed with the LLM provider. Please check your credentials.",
             { originalError: err }
           );
         }
       }
 
-      // For unknown errors, preserve the original error but wrap it
+      // For unknown errors from the LLM/SDK, preserve the original error but wrap it.
+      // Use a more generic error code here if it's not one of the above.
+      // Perhaps keep InvalidResponseFormat or create a new one like LLMInteractionError?
+      // Let's stick with InvalidResponseFormat for now as it often manifests as bad output.
       throw createError(
-        ErrorCode.InvalidResponseFormat,
-        "Failed to generate project plan",
-        { originalError: err }
+        ErrorCode.InvalidResponseFormat, // Fallback code
+        "Failed to generate project plan due to an unexpected error.", // Fallback message
+        { originalError: err } // Always include original error for debugging
       );
     }
   }

src/server/TaskManager.ts

@@ -45,28 +45,48 @@ function getCategoryFromCode(code: ErrorCode): ErrorCategory {
  * Converts any error to a StandardError
  */
 export function normalizeError(error: unknown): StandardError {
+  // 1. Check if it already looks like a StandardError (duck typing)
+  if (
+    typeof error === 'object' &&
+    error !== null &&
+    'status' in error && error.status === 'error' &&
+    'code' in error && typeof error.code === 'string' &&
+    'category' in error && typeof error.category === 'string' &&
+    'message' in error && typeof error.message === 'string' &&
+    Object.values(ErrorCode).includes(error.code as ErrorCode) // Verify the code is valid
+  ) {
+    // It already conforms to the StandardError structure, return as is.
+    // We cast because TypeScript knows it's 'object', but we've verified the shape.
+    return error as StandardError;
+  }
+
+  // 2. Check if it's an instance of Error
   if (error instanceof Error) {
-    // Try to parse error code from message if it exists
-    const codeMatch = error.message.match(/\[([A-Z_]+)\]/);
-    if (codeMatch && Object.values(ErrorCode).includes(codeMatch[1] as ErrorCode)) {
+    const codeMatch = error.message.match(/\[([A-Z_0-9]+)\]/);
+    // Ensure codeMatch exists and the captured group is a valid ErrorCode
+    if (codeMatch && codeMatch[1] && Object.values(ErrorCode).includes(codeMatch[1] as ErrorCode)) {
+      const extractedCode = codeMatch[1] as ErrorCode;
+      // Remove the code prefix "[CODE]" from the message - use the full match codeMatch[0] for replacement
+      const cleanedMessage = error.message.replace(codeMatch[0], '').trim();
       return createError(
-        codeMatch[1] as ErrorCode,
-        error.message.replace(`[${codeMatch[1]}]`, '').trim(),
-        { stack: error.stack }
+        extractedCode,
+        cleanedMessage,
+        { stack: error.stack } // Keep stack trace if available
       );
     }
 
-    // Default to unknown error
+    // Fallback for generic Errors without a recognized code in the message
     return createError(
-      ErrorCode.InvalidArgument,
+      ErrorCode.InvalidArgument, // Use InvalidArgument for generic errors
       error.message,
       { stack: error.stack }
     );
   }
 
+  // 3. Handle other types (string, primitive, plain object without structure)
   return createError(
     ErrorCode.Unknown,
     typeof error === 'string' ? error : 'An unknown error occurred',
-    { originalError: error }
+    { originalError: error } // Include the original unknown error type
   );
 } 

src/utils/errors.ts

@@ -181,25 +181,29 @@ describe("CLI Integration Tests", () => {
 
     it("should handle missing API key gracefully", async () => {
       delete process.env.OPENAI_API_KEY;
-      
+
       const { stderr } = await execAsync(
         `TASK_MANAGER_FILE_PATH=${tasksFilePath} tsx ${CLI_PATH} generate-plan --prompt "Create a todo app" --provider openai`
       ).catch(error => error);
-      
+
       // Verify we get an error with the error code format
       expect(stderr).toContain("[ERR_");
-      // The actual error might not contain "API key" text, so we'll just check for a general error
-      expect(stderr).toContain("An unknown error occurred");
+      // The actual error should contain "API key" text
+      expect(stderr).toContain("API key");
     }, 5000);
 
     it("should handle invalid file attachments gracefully", async () => {
-      const { stderr } = await execAsync(
+      const { stdout, stderr } = await execAsync(
         `TASK_MANAGER_FILE_PATH=${tasksFilePath} tsx ${CLI_PATH} generate-plan --prompt "Create app" --attachment nonexistent.txt`
-      ).catch(error => error);
+      ).catch(error => ({ stdout: error.stdout, stderr: error.stderr }));
+
+      // Keep these console logs temporarily if helpful for debugging during development
+      // console.log("Test stdout:", stdout); 
+      // console.log("Test stderr:", stderr);
 
-      // Just verify we get a warning about the attachment
-      expect(stderr).toContain("Warning:");
-      expect(stderr).toContain("nonexistent.txt");
+      // Updated assertion to match the formatCliError output
+      expect(stderr).toContain("[ERR_4000] Failed to read attachment file: nonexistent.txt");
+      expect(stderr).toContain("-> Details: Attachment file not found: nonexistent.txt");
     }, 5000);
   });
 });