@hauptsache.net/clickup-mcp 1.6.2 → 1.7.2

package/dist/shared/attachments.d.ts

@@ -0,0 +1,112 @@
+import { Buffer } from "buffer";
+/**
+ * Attachment object as returned by POST /api/v2/task/{task_id}/attachment.
+ * ClickUp only renders an image inside a comment when the fragment carries this
+ * whole object - a bare URL string renders as an empty placeholder tile.
+ */
+export interface ClickUpUploadedAttachment {
+    id: string;
+    name: string;
+    title?: string;
+    extension?: string;
+    url: string;
+    thumbnail_small?: string;
+    thumbnail_medium?: string;
+    thumbnail_large?: string;
+    width?: number;
+    height?: number;
+    [key: string]: any;
+}
+/** Image bytes ready to be uploaded */
+interface ResolvedBytes {
+    kind: "bytes";
+    bytes: Buffer;
+    mimeType: string;
+    suggestedName: string;
+}
+/** Already an attachment on ClickUp's CDN - reuse it instead of uploading again */
+interface ResolvedExisting {
+    kind: "existing";
+    url: string;
+}
+export type ResolvedImageSource = ResolvedBytes | ResolvedExisting;
+/**
+ * ClickUp serves attachments from *.clickup-attachments.com. Such a URL is
+ * already uploaded, so it can be embedded directly.
+ */
+export declare function isClickUpAttachmentUrl(url: string): boolean;
+/**
+ * Turn the `src` of a markdown image into something uploadable.
+ *
+ * Supported sources, in this order:
+ * - a ClickUp attachment URL      -> reused as-is, no upload
+ * - a base64 data URI             -> decoded
+ * - any other http(s) URL         -> downloaded
+ * - anything else                 -> read from the local filesystem
+ *
+ * The local path case is the interesting one: this server runs next to the agent,
+ * so a screenshot can be referenced by path instead of being inlined as base64,
+ * which would otherwise cost a multiple of the file size in tokens.
+ */
+export declare function resolveImageSource(src: string, baseDir?: string): Promise<ResolvedImageSource>;
+/**
+ * Derive the upload filename from the markdown alt text.
+ *
+ * ClickUp shows the *attachment filename* underneath an image, not the fragment
+ * text - so naming the upload after the caption is what makes a readable caption
+ * appear in the ticket.
+ */
+export declare function captionToFilename(caption: string, fallbackName: string): string;
+/**
+ * Upload a single image to a task and return the full attachment object.
+ */
+export declare function uploadTaskAttachment(taskId: string, filename: string, bytes: Buffer, mimeType: string): Promise<ClickUpUploadedAttachment>;
+/** A markdown image whose source resolved to uploadable bytes or an existing attachment */
+export interface ResolvedMarkdownImage {
+    /** The original `src` as written in the markdown */
+    src: string;
+    alt: string;
+    resolved: ResolvedImageSource;
+}
+/** One markdown image reference that could not be used, and why */
+export interface ImageFailure {
+    src: string;
+    error: string;
+}
+/**
+ * Phase 1 of attaching images: resolve every source without writing anything.
+ *
+ * Reads local files, downloads http(s) URLs, decodes data URIs and validates
+ * magic bytes and size. Failures are collected instead of thrown so the caller
+ * can report every broken reference at once - and abort before anything is
+ * posted to ClickUp. Identical sources are resolved once.
+ */
+export declare function resolveMarkdownImages(images: {
+    src: string;
+    alt: string;
+}[], baseDir?: string): Promise<{
+    resolved: ResolvedMarkdownImage[];
+    failures: ImageFailure[];
+}>;
+/** A successfully uploaded (or reused) attachment for one markdown source */
+export interface UploadedMarkdownImage {
+    src: string;
+    attachment: ClickUpUploadedAttachment;
+}
+/**
+ * Phase 2: upload the resolved images to the task.
+ *
+ * Uploads run sequentially: a typical comment has a handful of screenshots, and
+ * N uploads plus one write call stays well inside ClickUp's 100 calls/minute.
+ * Stops at the first upload error - an API failure is unlikely to heal mid-batch,
+ * and everything uploaded so far is returned so the caller can tell a retry to
+ * reference those CDN URLs directly instead of uploading again.
+ */
+export declare function uploadResolvedImages(taskId: string, images: ResolvedMarkdownImage[]): Promise<{
+    uploaded: UploadedMarkdownImage[];
+    failure: ImageFailure | null;
+}>;
+/** Map from markdown `src` to the attachment that should be embedded for it. */
+export declare function toAttachmentMap(uploaded: UploadedMarkdownImage[]): Map<string, ClickUpUploadedAttachment>;
+export {};
+//# sourceMappingURL=attachments.d.ts.map

package/dist/shared/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../../src/shared/attachments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAQhC;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,uCAAuC;AACvC,UAAU,aAAa;IACrB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,mFAAmF;AACnF,UAAU,gBAAgB;IACxB,IAAI,EAAE,UAAU,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG,gBAAgB,CAAC;AAoCnE;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAM3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAsB,GAC9B,OAAO,CAAC,mBAAmB,CAAC,CA2C9B;AAcD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAS/E;AAmCD;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,yBAAyB,CAAC,CAwBpC;AAED,2FAA2F;AAC3F,MAAM,WAAW,qBAAqB;IACpC,oDAAoD;IACpD,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,mBAAmB,CAAC;CAC/B;AAED,mEAAmE;AACnE,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,EACtC,OAAO,GAAE,MAAsB,GAC9B,OAAO,CAAC;IAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC;IAAC,QAAQ,EAAE,YAAY,EAAE,CAAA;CAAE,CAAC,CAqB1E;AAED,6EAA6E;AAC7E,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,yBAAyB,CAAC;CACvC;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,qBAAqB,EAAE,GAC9B,OAAO,CAAC;IAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC;IAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAAA;CAAE,CAAC,CAwC9E;AAED,gFAAgF;AAChF,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,qBAAqB,EAAE,GAChC,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAMxC"}

package/dist/shared/attachments.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClickUpAttachmentUrl = isClickUpAttachmentUrl;
+exports.resolveImageSource = resolveImageSource;
+exports.captionToFilename = captionToFilename;
+exports.uploadTaskAttachment = uploadTaskAttachment;
+exports.resolveMarkdownImages = resolveMarkdownImages;
+exports.uploadResolvedImages = uploadResolvedImages;
+exports.toAttachmentMap = toAttachmentMap;
+const buffer_1 = require("buffer");
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const config_1 = require("./config");
+const data_uri_1 = require("./data-uri");
+const image_processing_1 = require("./image-processing");
+const MIME_EXTENSIONS = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+};
+/**
+ * Detect the mime type from magic bytes and reject anything that is not an image
+ * we know how to display. This is both a correctness guard (ClickUp needs a real
+ * image to render a preview) and a safety guard: it stops arbitrary local files
+ * from being pushed into a ticket just because a path was mentioned in markdown.
+ */
+function assertSupportedImage(bytes, source) {
+    // Copy into a fresh view - Buffer instances share a pooled ArrayBuffer, so
+    // passing bytes.buffer directly would hand over unrelated neighbouring data.
+    const detected = (0, image_processing_1.detectMimeTypeFromBuffer)(new Uint8Array(bytes).buffer);
+    if (!detected) {
+        throw new Error(`${source} is not a supported image (expected PNG, JPEG, GIF or WebP based on its content)`);
+    }
+    return detected;
+}
+function assertWithinSizeLimit(byteLength, source) {
+    const limit = config_1.CONFIG.maxUploadSizeMB * 1024 * 1024;
+    if (byteLength > limit) {
+        throw new Error(`${source} is ${(byteLength / 1024 / 1024).toFixed(1)} MB which exceeds the ${config_1.CONFIG.maxUploadSizeMB} MB upload limit (raise MAX_UPLOAD_SIZE_MB to allow it)`);
+    }
+}
+/**
+ * ClickUp serves attachments from *.clickup-attachments.com. Such a URL is
+ * already uploaded, so it can be embedded directly.
+ */
+function isClickUpAttachmentUrl(url) {
+    try {
+        return new URL(url).hostname.endsWith(".clickup-attachments.com");
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Turn the `src` of a markdown image into something uploadable.
+ *
+ * Supported sources, in this order:
+ * - a ClickUp attachment URL      -> reused as-is, no upload
+ * - a base64 data URI             -> decoded
+ * - any other http(s) URL         -> downloaded
+ * - anything else                 -> read from the local filesystem
+ *
+ * The local path case is the interesting one: this server runs next to the agent,
+ * so a screenshot can be referenced by path instead of being inlined as base64,
+ * which would otherwise cost a multiple of the file size in tokens.
+ */
+async function resolveImageSource(src, baseDir = process.cwd()) {
+    if (isClickUpAttachmentUrl(src)) {
+        return { kind: "existing", url: src };
+    }
+    const dataUri = (0, data_uri_1.parseDataUri)(src);
+    if (dataUri) {
+        const bytes = buffer_1.Buffer.from(dataUri.base64Data, "base64");
+        assertWithinSizeLimit(bytes.byteLength, "The inline image");
+        const mimeType = assertSupportedImage(bytes, "The inline image");
+        return {
+            kind: "bytes",
+            bytes,
+            mimeType,
+            suggestedName: `image${MIME_EXTENSIONS[mimeType] ?? ".png"}`,
+        };
+    }
+    if (/^https?:\/\//i.test(src)) {
+        const response = await fetch(src);
+        if (!response.ok) {
+            throw new Error(`Could not download ${src}: ${response.status} ${response.statusText}`);
+        }
+        const bytes = buffer_1.Buffer.from(await response.arrayBuffer());
+        assertWithinSizeLimit(bytes.byteLength, src);
+        const mimeType = assertSupportedImage(bytes, src);
+        const urlName = (0, path_1.basename)(new URL(src).pathname) || `image${MIME_EXTENSIONS[mimeType] ?? ".png"}`;
+        return { kind: "bytes", bytes, mimeType, suggestedName: decodeURIComponent(urlName) };
+    }
+    const filePath = (0, path_1.isAbsolute)(src) ? src : (0, path_1.resolve)(baseDir, decodeFilePath(src));
+    let bytes;
+    try {
+        bytes = await (0, promises_1.readFile)(filePath);
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            throw new Error(`No such file: ${filePath}`);
+        }
+        throw new Error(`Could not read ${filePath}: ${error?.message || "unknown error"}`);
+    }
+    assertWithinSizeLimit(bytes.byteLength, filePath);
+    const mimeType = assertSupportedImage(bytes, filePath);
+    return { kind: "bytes", bytes, mimeType, suggestedName: (0, path_1.basename)(filePath) };
+}
+/**
+ * Markdown writers tend to percent-encode spaces in paths (`my%20shot.png`).
+ * Decode them, but leave the path alone if it is not valid encoding.
+ */
+function decodeFilePath(src) {
+    try {
+        return decodeURIComponent(src);
+    }
+    catch {
+        return src;
+    }
+}
+/**
+ * Derive the upload filename from the markdown alt text.
+ *
+ * ClickUp shows the *attachment filename* underneath an image, not the fragment
+ * text - so naming the upload after the caption is what makes a readable caption
+ * appear in the ticket.
+ */
+function captionToFilename(caption, fallbackName) {
+    const extension = (0, path_1.extname)(fallbackName) || ".png";
+    const cleaned = caption
+        .replace(/[/\\:*?"<>|]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 120)
+        .trim();
+    return cleaned ? `${cleaned}${extension}` : fallbackName;
+}
+/**
+ * Build the multipart/form-data body by hand.
+ *
+ * Deliberately not using `FormData`: the global FormData is only understood by the
+ * fetch implementation it ships with, so swapping fetch (as the tests do) silently
+ * turns the body into the string "[object FormData]". A hand-built buffer behaves
+ * identically everywhere and keeps the wire format assertable.
+ */
+function buildMultipartBody(filename, bytes, mimeType) {
+    const boundary = `----clickupmcp${(0, crypto_1.randomUUID)().replace(/-/g, "")}`;
+    // Quotes and newlines would break out of the header - strip them.
+    const safeName = filename.replace(/["\r\n]/g, "");
+    const head = buffer_1.Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="attachment"; filename="${safeName}"\r\n` +
+        `Content-Type: ${mimeType}\r\n\r\n`, "utf8");
+    const tail = buffer_1.Buffer.from(`\r\n--${boundary}--\r\n`, "utf8");
+    // Hand over a bare ArrayBuffer: Buffer and Uint8Array both trip up the BodyInit
+    // typing here. Copying into a fresh Uint8Array also detaches from Buffer's shared
+    // pool, so the ArrayBuffer contains exactly our bytes and nothing else.
+    const combined = new Uint8Array(buffer_1.Buffer.concat([head, bytes, tail]));
+    return {
+        body: combined.buffer,
+        contentType: `multipart/form-data; boundary=${boundary}`,
+    };
+}
+/**
+ * Upload a single image to a task and return the full attachment object.
+ */
+async function uploadTaskAttachment(taskId, filename, bytes, mimeType) {
+    const { body, contentType } = buildMultipartBody(filename, bytes, mimeType);
+    const response = await fetch(`https://api.clickup.com/api/v2/task/${taskId}/attachment`, {
+        method: "POST",
+        headers: {
+            Authorization: config_1.CONFIG.apiKey,
+            "Content-Type": contentType,
+        },
+        body,
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new Error(`Upload of "${filename}" failed: ${response.status} ${response.statusText}${errorText ? ` - ${errorText.slice(0, 300)}` : ""}`);
+    }
+    const attachment = (await response.json());
+    if (!attachment?.url) {
+        throw new Error(`Upload of "${filename}" returned no URL: ${JSON.stringify(attachment)}`);
+    }
+    return attachment;
+}
+/**
+ * Phase 1 of attaching images: resolve every source without writing anything.
+ *
+ * Reads local files, downloads http(s) URLs, decodes data URIs and validates
+ * magic bytes and size. Failures are collected instead of thrown so the caller
+ * can report every broken reference at once - and abort before anything is
+ * posted to ClickUp. Identical sources are resolved once.
+ */
+async function resolveMarkdownImages(images, baseDir = process.cwd()) {
+    const resolved = [];
+    const failures = [];
+    const seen = new Set();
+    for (const { src, alt } of images) {
+        if (seen.has(src)) {
+            continue;
+        }
+        seen.add(src);
+        try {
+            resolved.push({ src, alt, resolved: await resolveImageSource(src, baseDir) });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "unknown error";
+            console.error(`Cannot use image "${src}": ${message}`);
+            failures.push({ src, error: message });
+        }
+    }
+    return { resolved, failures };
+}
+/**
+ * Phase 2: upload the resolved images to the task.
+ *
+ * Uploads run sequentially: a typical comment has a handful of screenshots, and
+ * N uploads plus one write call stays well inside ClickUp's 100 calls/minute.
+ * Stops at the first upload error - an API failure is unlikely to heal mid-batch,
+ * and everything uploaded so far is returned so the caller can tell a retry to
+ * reference those CDN URLs directly instead of uploading again.
+ */
+async function uploadResolvedImages(taskId, images) {
+    const uploaded = [];
+    for (const { src, alt, resolved } of images) {
+        try {
+            if (resolved.kind === "existing") {
+                // Already on ClickUp's CDN - synthesise the minimal attachment shape so
+                // the fragment builder has something to work with.
+                const name = decodeURIComponent((0, path_1.basename)(new URL(resolved.url).pathname));
+                uploaded.push({
+                    src,
+                    attachment: {
+                        id: name,
+                        name,
+                        title: alt || name,
+                        extension: (0, path_1.extname)(name).replace(/^\./, "") || undefined,
+                        url: resolved.url,
+                        thumbnail_small: resolved.url,
+                        thumbnail_medium: resolved.url,
+                        thumbnail_large: resolved.url,
+                    },
+                });
+            }
+            else {
+                const filename = captionToFilename(alt, resolved.suggestedName);
+                const attachment = await uploadTaskAttachment(taskId, filename, resolved.bytes, resolved.mimeType);
+                uploaded.push({ src, attachment });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "unknown error";
+            console.error(`Failed to attach image "${src}": ${message}`);
+            return { uploaded, failure: { src, error: message } };
+        }
+    }
+    return { uploaded, failure: null };
+}
+/** Map from markdown `src` to the attachment that should be embedded for it. */
+function toAttachmentMap(uploaded) {
+    const map = new Map();
+    for (const { src, attachment } of uploaded) {
+        map.set(src, attachment);
+    }
+    return map;
+}

package/dist/shared/config.d.ts

@@ -5,6 +5,8 @@ export declare const CONFIG: {
     teamId: string;
     maxImages: number;
     maxResponseSizeMB: number;
+    maxUploadSizeMB: number;
+    commentEditWindowHours: number;
     primaryLanguageHint: string | undefined;
     mode: McpMode;
 };

package/dist/shared/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/shared/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,oBAA2D,CAAC;AAkDvF,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,OAAO,CAAC;AAUxD,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/shared/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,oBAA2D,CAAC;AAkDvF,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,OAAO,CAAC;AA8CxD,eAAO,MAAM,MAAM;;;;;;;;;CAqBlB,CAAC"}

package/dist/shared/config.js

@@ -48,11 +48,55 @@ if (rawMode === 'read-minimal' || rawMode === 'read') {
 else if (rawMode && rawMode !== 'write') {
     console.error(`Invalid CLICKUP_MCP_MODE "${rawMode}". Using default "write". Valid options: read-minimal, read, write`);
 }
+/**
+ * Numeric settings are exposed as optional MCPB user_config fields, so their env
+ * values can arrive blank or - if the host does not substitute an unset optional
+ * field - as the literal `${user_config.x}` placeholder. Both mean "not configured"
+ * and must fall back to the default rather than fail or turn into NaN.
+ */
+function readOptionalEnv(name) {
+    const raw = process.env[name]?.trim();
+    if (!raw || /^\$\{.*}$/.test(raw)) {
+        return undefined;
+    }
+    return raw;
+}
+/**
+ * A typo must not silently change a limit: `parseFloat("Infinity")` would disable
+ * the comment age check altogether and `parseFloat("abc")` would yield NaN, which
+ * compares false against every size and so lifts the upload limit instead of
+ * enforcing it. Fail at startup instead.
+ */
+function parseNumericEnv(name, fallback, { min, expectation }) {
+    const raw = readOptionalEnv(name);
+    if (raw === undefined) {
+        return fallback;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < min) {
+        throw new Error(`Invalid ${name} "${raw}". ${expectation}`);
+    }
+    return value;
+}
 exports.CONFIG = {
     apiKey: process.env.CLICKUP_API_KEY,
     teamId: process.env.CLICKUP_TEAM_ID,
     maxImages: process.env.MAX_IMAGES ? parseInt(process.env.MAX_IMAGES) : 4,
     maxResponseSizeMB: process.env.MAX_RESPONSE_SIZE_MB ? parseFloat(process.env.MAX_RESPONSE_SIZE_MB) : 1,
+    // Upper bound for a single image uploaded to ClickUp. Unlike maxResponseSizeMB this is
+    // not about context window budget - it only guards against accidentally pushing huge
+    // files into a ticket.
+    maxUploadSizeMB: parseNumericEnv("MAX_UPLOAD_SIZE_MB", 10, {
+        min: 1,
+        expectation: "Expected a positive number of megabytes.",
+    }),
+    // How long after creation a comment may still be edited. ClickUp has no way to tell
+    // "written by this MCP" apart from "written by the token owner in the UI", so this
+    // window is the actual guard against rewriting history. 0 disables editing entirely.
+    commentEditWindowHours: parseNumericEnv("CLICKUP_COMMENT_EDIT_WINDOW_HOURS", 24, {
+        min: 0,
+        expectation: "Expected a non-negative number of hours (0 disables editComment).",
+    }),
     primaryLanguageHint: detectedLanguageHint, // Store the cleaned code directly
     mode: mcpMode,
 };

package/dist/shared/image-processing.d.ts

@@ -1,4 +1,9 @@
 import { ContentBlock, ImageMetadataBlock } from "./types";
+/**
+ * Detect MIME type from image binary data using magic bytes (file signatures)
+ * Returns null if the format is not recognized
+ */
+export declare function detectMimeTypeFromBuffer(buffer: ArrayBuffer): string | null;
 /**
  * Downloads images from image_metadata blocks and applies smart size/count limiting
  * Prioritizes keeping the most recent images (assumes content is ordered with newest items last)

package/dist/shared/image-processing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-processing.d.ts","sourceRoot":"","sources":["../../src/shared/image-processing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,kBAAkB,EAAC,MAAM,SAAS,CAAC;AAmDzD;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,CAAC,YAAY,GAAG,kBAAkB,CAAC,EAAE,EAAE,SAAS,GAAE,MAAyB,EAAE,SAAS,GAAE,MAAiC,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA0BhM"}
+{"version":3,"file":"image-processing.d.ts","sourceRoot":"","sources":["../../src/shared/image-processing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,kBAAkB,EAAC,MAAM,SAAS,CAAC;AAKzD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CA0B3E;AAgBD;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,CAAC,YAAY,GAAG,kBAAkB,CAAC,EAAE,EAAE,SAAS,GAAE,MAAyB,EAAE,SAAS,GAAE,MAAiC,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA0BhM"}

package/dist/shared/image-processing.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectMimeTypeFromBuffer = detectMimeTypeFromBuffer;
 exports.downloadImages = downloadImages;
 const config_1 = require("./config");
 const data_uri_1 = require("./data-uri");

package/dist/tools/task-write-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-write-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-write-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAcpE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QAsZtE"}
+{"version":3,"file":"task-write-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-write-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA+IpE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QAumBtE"}