@sebastienheyd/clickup-mcp 1.7.3 → 1.8.0

package/dist/tools/task-write-tools.js

@@ -5,6 +5,88 @@ const zod_1 = require("zod");
 const config_1 = require("../shared/config");
 const utils_1 = require("../shared/utils");
 const clickup_text_1 = require("../clickup-text");
+const attachments_1 = require("../shared/attachments");
+/**
+ * Shared wording for the image support of every markdown field in this file.
+ * Kept in one place so the tools stay consistent about what a client may pass.
+ */
+const IMAGE_SUPPORT_HINT = [
+    "IMAGES: Reference images with normal markdown - `![caption](/absolute/path/to/screenshot.png)`.",
+    "This server runs locally, so a local file path is read and uploaded automatically - never inline a screenshot as base64 when a path exists, it costs orders of magnitude more tokens.",
+    "Also accepted: `data:` URIs, http(s) URLs (downloaded and re-uploaded), and existing ClickUp attachment URLs (embedded as-is).",
+    "The caption becomes the attachment filename, which is what ClickUp displays beneath the image - so write a caption that reads well.",
+].join("\n");
+/**
+ * Phase 1 of image handling: parse the markdown and resolve every image source
+ * (read files, download URLs, decode data URIs) WITHOUT writing anything.
+ *
+ * Throws when any reference is unusable, listing every broken source at once.
+ * Nothing has been posted to ClickUp when this throws, so the caller's generic
+ * error path returns the report and the client can fix the markdown and retry.
+ */
+async function resolveImagesOrAbort(markdown, abortNotice) {
+    if (!markdown) {
+        return { markdown: markdown ?? "", images: [] };
+    }
+    // Normalise first, then use the same string for collecting and converting - the
+    // sources must line up with what the converter later looks up.
+    const normalized = (0, clickup_text_1.normalizeImageDestinations)(markdown);
+    const sources = (0, clickup_text_1.collectMarkdownImageSources)(normalized);
+    if (sources.length === 0) {
+        return { markdown: normalized, images: [] };
+    }
+    const { resolved, failures } = await (0, attachments_1.resolveMarkdownImages)(sources);
+    if (failures.length > 0) {
+        throw new Error([
+            `${failures.length} image reference(s) could not be used, so ${abortNotice}:`,
+            ...failures.map((failure) => `  - ${failure.src}: ${failure.error}`),
+            `Fix or remove these image references and retry.`,
+        ].join("\n"));
+    }
+    return { markdown: normalized, images: resolved };
+}
+/**
+ * Phase 2: upload the resolved images to the task.
+ *
+ * Throws on the first upload failure. Everything uploaded before the failure is
+ * listed with its CDN URL so a retry can reference those URLs directly (existing
+ * ClickUp URLs are embedded without re-uploading).
+ */
+async function uploadImagesOrAbort(taskId, images, abortNotice) {
+    if (images.length === 0) {
+        return [];
+    }
+    const { uploaded, failure } = await (0, attachments_1.uploadResolvedImages)(taskId, images);
+    if (failure) {
+        const lines = [
+            `Uploading image "${failure.src}" failed, so ${abortNotice}:`,
+            `  ${failure.error}`,
+        ];
+        if (uploaded.length > 0) {
+            lines.push(`${uploaded.length} image(s) were already uploaded to task ${taskId} before the failure - on retry, reference these URLs directly to avoid duplicate uploads:`, ...uploaded.map((u) => `  - ${u.attachment.name}: ${u.attachment.url}`));
+        }
+        throw new Error(lines.join("\n"));
+    }
+    return uploaded;
+}
+/**
+ * Echo a markdown field back without repeating inline base64 payloads.
+ * Without this a single data-URI screenshot would be mirrored back into the
+ * response, costing as many tokens again as it did going in.
+ */
+function summarizeMarkdownForEcho(markdown) {
+    return markdown.replace(/(!\[[^\]]*\]\()data:([^;,)]+)[^)]*(\))/g, (_match, prefix, mimeType, suffix) => `${prefix}[inline ${mimeType} data]${suffix}`);
+}
+/** Report successfully attached images so the caller can verify and link to them */
+function formatAttachedImages(uploaded) {
+    if (uploaded.length === 0) {
+        return [];
+    }
+    return [
+        `images_attached: ${uploaded.length}`,
+        ...uploaded.map((u) => `  - ${u.attachment.name} (${u.attachment.url})`),
+    ];
+}
 // Shared schemas for task parameters
 const taskNameSchema = zod_1.z.string().min(1).describe("The name/title of the task");
 const taskPrioritySchema = zod_1.z.enum(["urgent", "high", "normal", "low"]).optional().describe("Optional priority level");
@@ -20,9 +102,12 @@ function registerTaskToolsWrite(server, userData) {
             "Adds a comment to a specific task.",
             "LINKING BEST PRACTICES:",
             "- Always reference related tasks using ClickUp URLs (https://app.clickup.com/t/TASK_ID)",
+            "- Task URLs become live task references (chip with task name and status), so write them bare - any custom link text on a task URL is replaced by the live task name",
             "- Include task links when mentioning dependencies, related work, or follow-ups",
             "- Link to relevant lists, spaces, or other ClickUp entities when applicable",
             "PROGRESS UPDATES: Include current status, progress information, and next steps.",
+            IMAGE_SUPPORT_HINT,
+            "IMAGE LAYOUT: An image inside a numbered list breaks ClickUp's numbering. Write walkthrough steps as bold lines with a blank line before and after the image instead (`**1. Open the login page**`).",
             "If external links are provided, verify they are publicly accessible and incorporate relevant information.",
             "Check the task's current status - if it's in 'backlog' or similar inactive states, suggest moving it to an active status like 'in progress' when work is being done."
         ];
@@ -43,8 +128,15 @@ function registerTaskToolsWrite(server, userData) {
         try {
             // Resolve custom task ID to internal ID if needed
             const resolved_task_id = await (0, utils_1.resolveTaskId)(task_id);
+            // Resolve and upload referenced images first - the fragments need the
+            // attachment objects from the upload response, a bare URL renders as an
+            // empty tile. Any image problem aborts BEFORE the comment is posted, so
+            // the caller can fix the markdown and retry without creating duplicates.
+            const abortNotice = "the comment was NOT posted";
+            const { markdown, images } = await resolveImagesOrAbort(comment, abortNotice);
+            const uploaded = await uploadImagesOrAbort(resolved_task_id, images, abortNotice);
             // Convert markdown to ClickUp formatted blocks
-            const commentBlocks = (0, clickup_text_1.convertMarkdownToClickUpBlocks)(comment);
+            const commentBlocks = (0, clickup_text_1.convertMarkdownToClickUpBlocks)(markdown, (0, attachments_1.toAttachmentMap)(uploaded));
             const requestBody = {
                 comment: commentBlocks,
                 notify_all: true
@@ -70,9 +162,10 @@ function registerTaskToolsWrite(server, userData) {
                             `Comment added successfully!`,
                             `comment_id: ${commentData.id || 'N/A'}`,
                             `task_id: ${resolved_task_id}`,
-                            `comment: ${comment}`,
+                            `comment: ${summarizeMarkdownForEcho(comment)}`,
                             `date: ${timestampToIso(commentData.date || Date.now())}`,
                             `user: ${commentData.user?.username || 'Current user'}`,
+                            ...formatAttachedImages(uploaded),
                         ].join('\n')
                     }
                 ],
@@ -90,6 +183,92 @@ function registerTaskToolsWrite(server, userData) {
             };
         }
     });
+    tool("editComment", (() => {
+        const descriptionBase = [
+            "Replaces the full text of an existing task comment - use this to correct a comment you just posted instead of adding a follow-up comment.",
+            "The new text REPLACES the old one completely, it is not appended. Anything worth keeping must be repeated in `comment`.",
+            `GUARDRAILS: only comments written by the API token's own user can be edited, and only within ${config_1.CONFIG.commentEditWindowHours} hours of their creation. Older comments and other people's comments must be answered with a new comment via addComment.`,
+            "ClickUp shows no 'edited' marker, so people who already read the comment will not notice the change - for anything that changes meaning after a discussion has started, prefer a follow-up comment.",
+            "Editing does not reset the creation date, so the edit window does not get extended by editing.",
+            IMAGE_SUPPORT_HINT,
+            "IMAGES ON EDIT: reading a comment (getTaskById) returns its images as markdown, so passing that text back keeps them - an existing ClickUp attachment URL is re-embedded without uploading again. Only an image whose markdown you drop disappears.",
+            "Task URLs (https://app.clickup.com/t/TASK_ID) become live task references, and existing references are read back as such URLs - passing the text back keeps them.",
+        ];
+        if (config_1.CONFIG.primaryLanguageHint && config_1.CONFIG.primaryLanguageHint.toLowerCase() !== 'en') {
+            descriptionBase.splice(1, 0, `For optimal results, consider writing comments in '${config_1.CONFIG.primaryLanguageHint}' unless the task is already in another language.`);
+        }
+        return descriptionBase.join("\n");
+    })(), {
+        task_id: zod_1.z.string().min(1).refine(val => (0, utils_1.isTaskId)(val) || (0, utils_1.isCustomTaskId)(val), {
+            message: "Must be an internal task ID (6+ alphanumeric characters) or a custom task ID (e.g. SOI-4422)"
+        }).describe("The ID of the task the comment belongs to - needed to locate the comment and to upload images. Internal ID (e.g. \"869c4za0g\") or custom ID (e.g. \"SOI-4422\")"),
+        comment_id: zod_1.z.string().min(1).describe("The ID of the comment to edit, as returned by addComment or getTaskById"),
+        comment: zod_1.z.string().min(1).describe("The new comment text, replacing the previous text completely"),
+    }, {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+    }, async ({ task_id, comment_id, comment }) => {
+        try {
+            // Resolve custom task ID to internal ID if needed
+            const resolved_task_id = await (0, utils_1.resolveTaskId)(task_id);
+            const [existing, userData] = await Promise.all([
+                findTaskComment(resolved_task_id, comment_id),
+                (0, utils_1.getCurrentUser)(),
+            ]);
+            assertCommentIsEditable(existing, userData.user.id);
+            // Same pipeline as addComment - the undocumented rich `comment` array is
+            // accepted by PUT too, so formatting and images survive an edit. Images are
+            // resolved and uploaded before the PUT, so a broken reference leaves the
+            // existing comment untouched.
+            const abortNotice = "the comment was NOT changed";
+            const { markdown, images } = await resolveImagesOrAbort(comment, abortNotice);
+            const uploaded = await uploadImagesOrAbort(resolved_task_id, images, abortNotice);
+            const commentBlocks = (0, clickup_text_1.convertMarkdownToClickUpBlocks)(markdown, (0, attachments_1.toAttachmentMap)(uploaded));
+            // Only `comment` is sent: sending `comment_text` alongside it appends that
+            // string to the blocks instead of being ignored.
+            const response = await fetch(`https://api.clickup.com/api/v2/comment/${comment_id}`, {
+                method: 'PUT',
+                headers: {
+                    Authorization: config_1.CONFIG.apiKey,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ comment: commentBlocks })
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(`Error editing comment: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `Comment edited successfully!`,
+                            `comment_id: ${comment_id}`,
+                            `task_id: ${resolved_task_id}`,
+                            `task_url: https://app.clickup.com/t/${resolved_task_id}`,
+                            `created: ${timestampToIso(existing.date)} (unchanged by the edit)`,
+                            `previous_text: ${existing.comment_text || '(no plain text available)'}`,
+                            `new_comment: ${summarizeMarkdownForEcho(comment)}`,
+                            ...formatAttachedImages(uploaded),
+                        ].join('\n')
+                    }
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error editing comment:', error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error editing comment: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
     tool("updateTask", (() => {
         const descriptionBase = [
             "Updates various aspects of an existing task including dependencies and relationships.",
@@ -97,6 +276,7 @@ function registerTaskToolsWrite(server, userData) {
             "Use getListInfo first to see valid status options.",
             "SAFETY FEATURE: Description updates are APPEND-ONLY to prevent data loss - existing content is preserved.",
             "STATUS UPDATES: Use the `addComment` tool for progress reports, work logs, and status updates rather than the task description.",
+            IMAGE_SUPPORT_HINT,
             "Task descriptions should contain requirements, specifications, and core task information.",
             "LINKING IN DESCRIPTIONS: When appending descriptions, include links to related tasks, lists, or external resources.",
             "IMPORTANT: When updating tasks (especially when booking time or adding progress), ensure the status makes sense for the work being done - tasks in 'backlog' or 'closed' states usually shouldn't have active work.",
@@ -141,6 +321,19 @@ function registerTaskToolsWrite(server, userData) {
                 throw new Error(`Error fetching task: ${taskResponse.status} ${taskResponse.statusText}`);
             }
             const taskData = await taskResponse.json();
+            // Resolve and upload description images FIRST - an image problem must
+            // abort before dependencies, tags or the task itself are touched, so the
+            // caller can fix the markdown and retry the whole call cleanly.
+            let appendedDescription;
+            let uploadedImages = [];
+            if (append_description) {
+                const abortNotice = "the task was NOT updated";
+                const prepared = await resolveImagesOrAbort(append_description, abortNotice);
+                uploadedImages = await uploadImagesOrAbort(resolved_task_id, prepared.images, abortNotice);
+                // Descriptions render plain markdown, so no image fragments are involved
+                // here - the local paths are simply swapped for the CDN URLs.
+                appendedDescription = (0, clickup_text_1.rewriteMarkdownImageUrls)(prepared.markdown, (0, attachments_1.toAttachmentMap)(uploadedImages));
+            }
             // Handle dependencies separately since they need individual API calls
             let dependencyUpdateResults = [];
             if (blocking !== undefined || waiting_on !== undefined || linked_tasks !== undefined) {
@@ -191,11 +384,11 @@ function registerTaskToolsWrite(server, userData) {
             }
             // Handle append-only description update with markdown support
             let finalDescription;
-            if (append_description) {
+            if (appendedDescription !== undefined) {
                 const currentDescription = taskData.markdown_description || "";
                 const timestamp = new Date().toISOString().split('T')[0]; // YYYY-MM-DD format
                 const separator = currentDescription.trim() ? "\n\n---\n" : "";
-                finalDescription = currentDescription + separator + `**Edit (${timestamp}):** ${append_description}`;
+                finalDescription = currentDescription + separator + `**Edit (${timestamp}):** ${appendedDescription}`;
             }
             // Build update body without tags (they're handled separately)
             const updateBody = buildTaskRequestBody({
@@ -257,6 +450,7 @@ function registerTaskToolsWrite(server, userData) {
             if (tagUpdateResults.length > 0) {
                 responseLines.push('tag_warnings: ' + tagUpdateResults.join('; '));
             }
+            responseLines.push(...formatAttachedImages(uploadedImages));
             return {
                 content: [
                     {
@@ -288,6 +482,7 @@ function registerTaskToolsWrite(server, userData) {
             "- The response will include the new task's clickable URL - always share this link",
             "Use getListInfo first to understand the list context and available statuses.",
             "Task descriptions support full markdown formatting including **bold**, *italic*, lists, links, and code blocks.",
+            IMAGE_SUPPORT_HINT,
             "BEST PRACTICE: Every task creation should result in sharing the clickable task URL for future reference."
         ];
         if (config_1.CONFIG.primaryLanguageHint && config_1.CONFIG.primaryLanguageHint.toLowerCase() !== 'en') {
@@ -313,6 +508,11 @@ function registerTaskToolsWrite(server, userData) {
         openWorldHint: true
     }, async ({ list_id, name, description, status, priority, due_date, start_date, time_estimate, tags, parent_task_id, assignees }) => {
         try {
+            // Resolve description images BEFORE creating the task: a broken reference
+            // (missing file, dead URL, non-image) must not leave a half-finished task
+            // behind. Uploading has to wait until the task exists, though - ClickUp
+            // attachments always belong to a task.
+            const { markdown: normalizedDescription, images } = await resolveImagesOrAbort(description, "the task was NOT created");
             const userData = await (0, utils_1.getCurrentUser)();
             const currentUserId = userData.user.id;
             const requestBody = buildTaskRequestBody({
@@ -358,9 +558,41 @@ function registerTaskToolsWrite(server, userData) {
                     createdTask = await refreshResponse.json();
                 }
             }
+            // Images can only be attached once the task exists, so the description is
+            // written first with its original sources and then rewritten to the CDN URLs.
+            // At this point every source resolved successfully - only the upload API
+            // itself can still fail, and then the task already exists, so that is
+            // reported as a warning instead of pretending the task was not created.
+            const imageWarnings = [];
+            const { uploaded, failure: uploadFailure } = await (0, attachments_1.uploadResolvedImages)(createdTask.id, images);
+            if (uploadFailure) {
+                console.error(`Failed to attach image "${uploadFailure.src}": ${uploadFailure.error}`);
+                imageWarnings.push(`WARNING: the task was created, but uploading image "${uploadFailure.src}" failed: ${uploadFailure.error}`, `The description still references the original image source. Fix the problem and add the image via updateTask.`);
+            }
+            const attachmentMap = (0, attachments_1.toAttachmentMap)(uploaded);
+            if (description && attachmentMap.size > 0) {
+                const rewritten = (0, clickup_text_1.rewriteMarkdownImageUrls)(normalizedDescription, attachmentMap);
+                if (rewritten !== description) {
+                    const descriptionResponse = await fetch(`https://api.clickup.com/api/v2/task/${createdTask.id}`, {
+                        method: 'PUT',
+                        headers: {
+                            Authorization: config_1.CONFIG.apiKey,
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({ markdown_description: rewritten })
+                    });
+                    if (!descriptionResponse.ok) {
+                        // The task itself exists - report the problem instead of failing the call.
+                        console.error(`Failed to write image URLs into description: ${descriptionResponse.status}`);
+                        imageWarnings.push(`WARNING: description update failed (${descriptionResponse.status} ${descriptionResponse.statusText}) - the images are attached to the task but not embedded in the description`);
+                    }
+                }
+            }
             const responseLines = formatTaskResponse(createdTask, 'created', {
                 list_id, name, description, status, priority, due_date, start_date, time_estimate, tags, parent_task_id, assignees
             }, userData);
+            responseLines.push(...formatAttachedImages(uploaded));
+            responseLines.push(...imageWarnings);
             return {
                 content: [
                     {
@@ -406,6 +638,93 @@ function formatTimeEstimate(hours) {
     const displayMinutes = Math.round((hours - displayHours) * 60);
     return displayHours > 0 ? `${displayHours}h ${displayMinutes}m` : `${displayMinutes}m`;
 }
+/**
+ * Never page further back than this. A generous edit window would otherwise walk
+ * the entire comment history of a busy ticket and eat the 100 calls/minute budget.
+ */
+const MAX_COMMENT_PAGES = 10;
+/** One page of task comments, newest first, 25 per page */
+async function fetchCommentPage(taskId, cursor) {
+    // Note there is no `start_date` parameter - passing one is silently ignored.
+    // Older pages are reached with `start` + `start_id` of the previous page's last entry.
+    const query = cursor
+        ? `?${new URLSearchParams({ start: cursor.start, start_id: cursor.startId })}`
+        : "";
+    const response = await fetch(`https://api.clickup.com/api/v2/task/${taskId}/comment${query}`, { headers: { Authorization: config_1.CONFIG.apiKey } });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(`Error loading comments of task ${taskId}: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
+    }
+    const data = await response.json();
+    return Array.isArray(data.comments) ? data.comments : [];
+}
+/**
+ * Load a single comment of a task.
+ *
+ * ClickUp has no `GET /comment/{id}`, so the task's comment list is the only way
+ * to learn a comment's author and age - both of which editComment has to check
+ * before touching anything.
+ *
+ * The list returns the 25 newest comments per page, so a busy ticket needs paging
+ * to reach the wanted comment. Paging stops as soon as a page ends outside the edit
+ * window: everything older would be refused anyway, which keeps this to a single
+ * request in the normal case.
+ *
+ * Note the list only contains top-level comments; replies inside a thread live
+ * behind `/comment/{parent_id}/reply` and are therefore not editable here.
+ */
+async function findTaskComment(taskId, commentId) {
+    const oldestEditableDate = Date.now() - config_1.CONFIG.commentEditWindowHours * 60 * 60 * 1000;
+    let cursor;
+    let checked = 0;
+    let pages = 0;
+    let sawThreadedReplies = false;
+    while (pages < MAX_COMMENT_PAGES) {
+        const page = await fetchCommentPage(taskId, cursor);
+        pages++;
+        if (page.length === 0) {
+            break;
+        }
+        const match = page.find((entry) => String(entry.id) === String(commentId));
+        if (match) {
+            return match;
+        }
+        checked += page.length;
+        sawThreadedReplies || (sawThreadedReplies = page.some((entry) => (entry.reply_count ?? 0) > 0));
+        // Comments come back newest first, so once a page runs past the edit window
+        // there is nothing editable further back.
+        const oldest = page[page.length - 1];
+        if (Number(oldest.date) < oldestEditableDate) {
+            break;
+        }
+        cursor = { start: String(oldest.date), startId: String(oldest.id) };
+    }
+    const threadedHint = sawThreadedReplies
+        ? " This task has threaded replies, and replies inside a thread cannot be edited - answer them with a new comment instead."
+        : "";
+    throw new Error(`Comment ${commentId} was not found on task ${taskId} (${checked} top-level comment(s) checked across ${pages} page(s), newest first).${threadedHint}`);
+}
+/**
+ * The whole safety model of editComment.
+ *
+ * ClickUp cannot tell "written through this MCP" from "written by the token owner
+ * in the web UI" - both carry the same user id - so the author check only keeps
+ * other people's comments safe, and the time window is what keeps the tool from
+ * rewriting history.
+ */
+function assertCommentIsEditable(comment, currentUserId) {
+    const windowHours = config_1.CONFIG.commentEditWindowHours;
+    if (!(windowHours > 0)) {
+        throw new Error(`Editing comments is disabled (CLICKUP_COMMENT_EDIT_WINDOW_HOURS=${windowHours}). Add a new comment instead.`);
+    }
+    if (String(comment.user?.id ?? '') !== String(currentUserId)) {
+        throw new Error(`Comment ${comment.id} was written by ${comment.user?.username || 'someone else'} (user_id: ${comment.user?.id ?? 'unknown'}), not by the current user (user_id: ${currentUserId}). Only your own comments can be edited - reply with a new comment instead.`);
+    }
+    const ageHours = (Date.now() - Number(comment.date)) / (1000 * 60 * 60);
+    if (ageHours > windowHours) {
+        throw new Error(`Comment ${comment.id} was created ${ageHours.toFixed(1)} hours ago (${timestampToIso(comment.date)}), which is outside the ${windowHours} hour edit window. Add a new comment instead of rewriting an old one.`);
+    }
+}
 /**
  * Formats timestamp to ISO string with local timezone (not UTC)
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebastienheyd/clickup-mcp",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "description": "Search, create, and retrieve tasks, add comments, and track time through natural language commands.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,11 +16,12 @@
     "start": "node dist/index.js",
     "dev": "npx tsc -w & nodemon dist/index.js",
     "cli": "npx ts-node src/cli.ts",
+    "smoke": "npx ts-node src/protocol-smoke.ts",
     "prettier": "prettier --write src/**/*.ts",
-    "prepublishOnly": "rm -r dist && npm run build",
+    "prepublishOnly": "rm -r dist && npm run build && chmod +x dist/index.js",
     "release": "npm run build && npm publish --access public && git add . && git commit -m \"Release v$(node -p 'require(\"./package.json\").version')\" && git tag -a v$(node -p 'require(\"./package.json\").version') -m \"Release v$(node -p 'require(\"./package.json\").version')\" && git push && git push --tags",
     "mcpb": "npm run build && mcpb pack . ClickUp.mcpb",
-    "test": "node --test -r ts-node/register src/**/*.test.ts"
+    "test": "node --test -r ts-node/register -r ./src/tests/setup.ts src/**/*.test.ts"
   },
   "keywords": [
     "clickup",