devchain-cli 0.20.3 → 0.22.0

package/dist/server/modules/external-integrations/adapters/clickup-external-task.provider.js

@@ -0,0 +1,1404 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClickUpExternalTaskProvider = void 0;
+const common_1 = require("@nestjs/common");
+const external_provider_errors_1 = require("../errors/external-provider.errors");
+const external_provider_models_1 = require("../models/external-provider.models");
+const external_task_source_1 = require("../models/external-task-source");
+const external_comment_lookup_token_1 = require("../models/external-comment-lookup-token");
+const clickup_comment_converter_1 = require("./rich/clickup-comment-converter");
+const clickup_comment_converter_2 = require("./rich/clickup-comment-converter");
+const safe_vendor_http_client_1 = require("../transport/safe-vendor-http-client");
+const vendor_shared_1 = require("./vendor-shared");
+const CLICKUP_ORIGIN = 'https://api.clickup.com';
+const CLICKUP_TASK_PAGE_SIZE = 100;
+const CLICKUP_MAX_TASK_PAGES = 1_000;
+const CLICKUP_COMMENT_PAGE_SIZE = 25;
+const CLICKUP_SUBTASK_PAGE_SIZE = 100;
+const CLICKUP_SUBTASK_MAX_PAGES = 10;
+const CLICKUP_OWNERSHIP_PREFIX = 'DevChain ownership token: `';
+const CLICKUP_OWNERSHIP_SUFFIX = '`';
+const CLICKUP_COMMENT_CURSOR_PATTERN = /^[A-Za-z0-9_-]+$/;
+const CLICKUP_COMMENT_AUTHOR = {
+    nameKey: 'username',
+    idKey: 'id',
+    idFormat: 'identifier',
+};
+let ClickUpExternalTaskProvider = class ClickUpExternalTaskProvider {
+    http;
+    provider = 'clickup';
+    descriptor = {
+        provider: this.provider,
+        displayName: 'ClickUp',
+        capabilities: { myWork: true },
+    };
+    myWork = {
+        discover: (credentials, options) => this.discoverMyWork(credentials, options),
+        getTaskDetail: (credentials, context, remoteTaskId) => this.getTaskDetail(credentials, context, remoteTaskId),
+        listComments: (credentials, context, remoteTaskId, cursor) => this.listTaskComments(credentials, context, remoteTaskId, cursor),
+        changeStatus: (credentials, context, remoteTaskId, input) => this.changeTaskStatus(credentials, context, remoteTaskId, input),
+        addComment: (credentials, context, remoteTaskId, input) => this.addTaskComment(credentials, context, remoteTaskId, input),
+        getTimeEntryHistory: (credentials, context, remoteTaskId) => this.getTaskTimeEntryHistory(credentials, context, remoteTaskId),
+    };
+    timeEntryMutations = {
+        createTimeEntry: (credentials, context, remoteTaskId, input) => this.createTimeEntry(credentials, context, remoteTaskId, input),
+        deleteTimeEntry: (credentials, context, remoteTaskId, remoteEntryId) => this.deleteTimeEntry(credentials, context, remoteTaskId, remoteEntryId),
+        readTimeEntryExact: (credentials, context, remoteTaskId, remoteEntryId) => this.readTimeEntryExact(credentials, context, remoteTaskId, remoteEntryId),
+        listOwnTimeEntryIdsInRange: (credentials, context, remoteTaskId, startedAfterMs, startedBeforeMs) => this.listOwnTimeEntryIdsInRange(credentials, context, remoteTaskId, startedAfterMs, startedBeforeMs),
+        assertTimeEntryDeletable: (credentials, context, remoteTaskId, remoteEntryId) => this.assertTimeEntryDeletable(credentials, context, remoteTaskId, remoteEntryId),
+    };
+    listMetadataCache = new vendor_shared_1.VendorMetadataCache(vendor_shared_1.WORK_AREA_METADATA_CACHE_MAX_ENTRIES);
+    validate = (0, vendor_shared_1.createVendorValidators)((reason) => new external_provider_errors_1.ClickUpProviderError(reason));
+    constructor(http) {
+        this.http = http;
+    }
+    ownedMutations = {
+        getCurrentOwnerRemoteId: (credentials) => this.getCurrentOwnerRemoteId(credentials),
+        findComment: (credentials, context, remoteTaskId, commentId, pageProof) => this.findComment(credentials, context, remoteTaskId, commentId, pageProof),
+        deleteComment: (credentials, context, remoteTaskId, commentId) => this.deleteComment(credentials, context, remoteTaskId, commentId),
+        updateOwnedComment: (credentials, context, remoteTaskId, commentId, document, metadata) => this.updateOwnedComment(credentials, context, remoteTaskId, commentId, document, metadata),
+    };
+    descriptionEdit = {
+        readDescription: (credentials, context, remoteTaskId) => this.readDescription(credentials, context, remoteTaskId),
+        writeDescription: (credentials, context, remoteTaskId, raw) => this.writeDescription(credentials, context, remoteTaskId, raw),
+    };
+    subtaskSync = {
+        create: (credentials, context, input) => this.createSubtask(credentials, context, input),
+        readExact: (credentials, context, remoteTaskId) => this.readSubtaskExact(credentials, context, remoteTaskId),
+        update: (credentials, context, input) => this.updateSubtask(credentials, context, input),
+        delete: (credentials, context, proof) => this.deleteSubtask(credentials, context, proof),
+        listOwnedDirectChildren: (credentials, context, parentRemoteTaskId, ownershipToken) => this.listOwnedDirectChildren(credentials, context, parentRemoteTaskId, ownershipToken),
+        assertOwned: (credentials, context, proof) => this.assertOwnedSubtask(credentials, context, proof),
+    };
+    async createSubtask(credentials, _context, input) {
+        const token = this.requireToken(credentials);
+        const parentTaskId = this.validate.requiredTaskId(input.parentRemoteTaskId);
+        const ownershipToken = this.requireSubtaskOwnershipToken(input.ownershipToken);
+        const title = this.requireSubtaskTitle(input.title);
+        const description = this.requireSubtaskDescription(input.description);
+        const parent = await this.readClickUpTaskExact(token, parentTaskId);
+        if (parent === null) {
+            throw new external_provider_errors_1.ClickUpProviderError('not_found');
+        }
+        const ownerRemoteId = await this.getCurrentOwnerRemoteId(credentials);
+        const ownerId = Number(ownerRemoteId);
+        if (!/^\d+$/.test(ownerRemoteId) || !Number.isSafeInteger(ownerId) || ownerId <= 0) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/list/${encodeURIComponent(parent.workAreaRemoteId)}/task`, {
+            method: 'POST',
+            body: JSON.stringify({
+                name: title,
+                markdown_content: this.managedMarkdown(description, ownershipToken),
+                parent: parentTaskId,
+                assignees: [ownerId],
+            }),
+        });
+        try {
+            if (!(0, vendor_shared_1.isRecord)(payload) || !(0, vendor_shared_1.isRecord)(payload.list)) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            const remoteTaskId = this.validate.requiredIdentifier(payload.id);
+            const parentRemoteTaskId = this.validate.requiredIdentifier(payload.parent);
+            const workAreaRemoteId = this.validate.requiredIdentifier(payload.list.id);
+            if (parentRemoteTaskId !== parentTaskId ||
+                workAreaRemoteId !== parent.workAreaRemoteId ||
+                this.validate.requiredString(payload.name) !== title) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            return {
+                remoteTaskId,
+                remoteKey: this.optionalIdentifier(payload.custom_id) ?? remoteTaskId,
+                parentRemoteTaskId,
+                workAreaRemoteId,
+                ownershipToken,
+                title,
+                description,
+            };
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.ClickUpProviderError) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response', undefined, true);
+            }
+            throw error;
+        }
+    }
+    async readSubtaskExact(credentials, _context, remoteTaskId) {
+        return this.readClickUpTaskExact(this.requireToken(credentials), this.validate.requiredTaskId(remoteTaskId));
+    }
+    async readClickUpTaskExact(token, taskId) {
+        const url = new URL(`${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}`);
+        url.searchParams.set('include_markdown_description', 'true');
+        try {
+            const payload = await this.requestJson(token, url.toString());
+            const snapshot = this.normalizeManagedSubtask(payload);
+            if (snapshot.remoteTaskId !== taskId) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            return snapshot;
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.ClickUpProviderError && error.details?.reason === 'not_found') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async updateSubtask(credentials, context, input) {
+        const current = await this.assertOwnedSubtask(credentials, context, input);
+        const body = {};
+        if (input.title !== undefined) {
+            body.name = this.requireSubtaskTitle(input.title);
+        }
+        if (input.description !== undefined) {
+            body.markdown_content = this.managedMarkdown(this.requireSubtaskDescription(input.description), this.requireSubtaskOwnershipToken(input.ownershipToken));
+        }
+        if (Object.keys(body).length === 0) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        const payload = await this.requestJson(this.requireToken(credentials), `${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(current.remoteTaskId)}`, { method: 'PUT', body: JSON.stringify(body) });
+        if (!(0, vendor_shared_1.isRecord)(payload) ||
+            this.validate.requiredIdentifier(payload.id) !== current.remoteTaskId) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response', undefined, true);
+        }
+    }
+    async deleteSubtask(credentials, context, proof) {
+        const current = await this.readSubtaskExact(credentials, context, proof.remoteTaskId);
+        if (current === null) {
+            return { outcome: 'already_absent' };
+        }
+        this.assertSubtaskProof(current, proof);
+        try {
+            await this.requestNoContent(this.requireToken(credentials), `${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(current.remoteTaskId)}`, { method: 'DELETE' });
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.ClickUpProviderError && error.details?.reason === 'not_found') {
+                return { outcome: 'already_absent' };
+            }
+            throw error;
+        }
+        return { outcome: 'deleted' };
+    }
+    async listOwnedDirectChildren(credentials, _context, parentRemoteTaskId, ownershipToken) {
+        const token = this.requireToken(credentials);
+        const parentTaskId = this.validate.requiredTaskId(parentRemoteTaskId);
+        const normalizedToken = this.requireSubtaskOwnershipToken(ownershipToken);
+        const parent = await this.readClickUpTaskExact(token, parentTaskId);
+        if (parent === null) {
+            throw new external_provider_errors_1.ClickUpProviderError('not_found');
+        }
+        const items = new Map();
+        for (let page = 0; page < CLICKUP_SUBTASK_MAX_PAGES; page += 1) {
+            const url = new URL(`${CLICKUP_ORIGIN}/api/v2/list/${encodeURIComponent(parent.workAreaRemoteId)}/task`);
+            url.searchParams.set('page', String(page));
+            url.searchParams.set('subtasks', 'true');
+            url.searchParams.set('include_closed', 'true');
+            url.searchParams.set('include_markdown_description', 'true');
+            const payload = await this.requestJson(token, url.toString());
+            if (!(0, vendor_shared_1.isRecord)(payload) ||
+                !Array.isArray(payload.tasks) ||
+                payload.tasks.length > CLICKUP_SUBTASK_PAGE_SIZE) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            for (const raw of payload.tasks) {
+                const child = this.normalizeManagedSubtask(raw);
+                if (child.parentRemoteTaskId === parentTaskId && child.ownershipToken === normalizedToken) {
+                    items.set(child.remoteTaskId, child);
+                }
+            }
+            if (payload.tasks.length < CLICKUP_SUBTASK_PAGE_SIZE) {
+                return { items: [...items.values()], complete: true };
+            }
+        }
+        return { items: [...items.values()], complete: false };
+    }
+    async assertOwnedSubtask(credentials, context, proof) {
+        const current = await this.readSubtaskExact(credentials, context, proof.remoteTaskId);
+        if (current === null) {
+            throw new external_provider_errors_1.ClickUpProviderError('not_found');
+        }
+        this.assertSubtaskProof(current, proof);
+        return current;
+    }
+    assertSubtaskProof(current, proof) {
+        const ownershipToken = this.requireSubtaskOwnershipToken(proof.ownershipToken);
+        const expectedParent = this.validate.requiredTaskId(proof.expectedParentRemoteTaskId);
+        if (current.ownershipToken !== ownershipToken) {
+            throw new external_provider_errors_1.ClickUpProviderError('ownership_mismatch');
+        }
+        if (current.parentRemoteTaskId !== expectedParent) {
+            throw new external_provider_errors_1.ClickUpProviderError('parent_mismatch');
+        }
+    }
+    normalizeManagedSubtask(value) {
+        if (!(0, vendor_shared_1.isRecord)(value) || !(0, vendor_shared_1.isRecord)(value.list)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const remoteTaskId = this.validate.requiredIdentifier(value.id);
+        const customId = this.optionalIdentifier(value.custom_id);
+        const parentRemoteTaskId = value.parent === null || value.parent === undefined
+            ? null
+            : this.validate.requiredIdentifier(value.parent);
+        const markdown = value.markdown_description;
+        if (markdown !== null && markdown !== undefined && typeof markdown !== 'string') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const managed = this.parseManagedMarkdown(markdown ?? null);
+        return {
+            remoteTaskId,
+            remoteKey: customId ?? remoteTaskId,
+            parentRemoteTaskId,
+            workAreaRemoteId: this.validate.requiredIdentifier(value.list.id),
+            ownershipToken: managed.ownershipToken,
+            title: this.validate.requiredString(value.name),
+            description: managed.description,
+        };
+    }
+    managedMarkdown(description, ownershipToken) {
+        const footer = `${external_provider_models_1.EXTERNAL_SUBTASK_MANAGEMENT_NOTE}\n\n${CLICKUP_OWNERSHIP_PREFIX}${ownershipToken}${CLICKUP_OWNERSHIP_SUFFIX}`;
+        return description === null ? footer : `${description}\n\n${footer}`;
+    }
+    parseManagedMarkdown(value) {
+        if (value === null || value === '') {
+            return { description: null, ownershipToken: null };
+        }
+        const notePosition = value.lastIndexOf(`\n\n${external_provider_models_1.EXTERNAL_SUBTASK_MANAGEMENT_NOTE}\n\n`);
+        const startsWithNote = value.startsWith(`${external_provider_models_1.EXTERNAL_SUBTASK_MANAGEMENT_NOTE}\n\n`);
+        const markerStart = notePosition >= 0
+            ? notePosition + 2 + external_provider_models_1.EXTERNAL_SUBTASK_MANAGEMENT_NOTE.length + 2
+            : startsWithNote
+                ? external_provider_models_1.EXTERNAL_SUBTASK_MANAGEMENT_NOTE.length + 2
+                : -1;
+        if (markerStart < 0 || !value.startsWith(CLICKUP_OWNERSHIP_PREFIX, markerStart)) {
+            return { description: value || null, ownershipToken: null };
+        }
+        const tokenStart = markerStart + CLICKUP_OWNERSHIP_PREFIX.length;
+        if (!value.endsWith(CLICKUP_OWNERSHIP_SUFFIX)) {
+            return { description: value || null, ownershipToken: null };
+        }
+        const token = value.slice(tokenStart, -CLICKUP_OWNERSHIP_SUFFIX.length);
+        if (!this.isSubtaskOwnershipToken(token)) {
+            return { description: value || null, ownershipToken: null };
+        }
+        const description = notePosition > 0 ? value.slice(0, notePosition) : null;
+        return { description: description || null, ownershipToken: token };
+    }
+    requireSubtaskTitle(value) {
+        if (typeof value !== 'string' ||
+            !value.trim() ||
+            value.length > external_provider_models_1.MAX_EXTERNAL_SUBTASK_TITLE_LENGTH) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        return value.trim();
+    }
+    requireSubtaskDescription(value) {
+        if (value === null || value === '') {
+            return null;
+        }
+        if (typeof value !== 'string' || value.length > external_provider_models_1.MAX_EXTERNAL_SUBTASK_DESCRIPTION_LENGTH) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        return value;
+    }
+    isSubtaskOwnershipToken(value) {
+        return (value.length <= external_provider_models_1.MAX_EXTERNAL_SUBTASK_OWNERSHIP_TOKEN_LENGTH &&
+            /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value));
+    }
+    requireSubtaskOwnershipToken(value) {
+        if (typeof value !== 'string' || !this.isSubtaskOwnershipToken(value)) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        return value;
+    }
+    async getCurrentOwnerRemoteId(credentials) {
+        const token = this.requireToken(credentials);
+        const payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/user`);
+        const dto = payload;
+        return this.validate.requiredIdentifier(dto?.user?.id);
+    }
+    async findComment(credentials, _context, remoteTaskId, commentId, pageProof) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const normalizedCommentId = this.validate.requiredIdentifier(commentId);
+        let position = pageProof === null ? null : this.decodeCommentCursor(pageProof);
+        for (let hop = 0; hop < 2; hop += 1) {
+            const url = new URL(`${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}/comment`);
+            if (position) {
+                url.searchParams.set('start', String(position.date));
+                url.searchParams.set('start_id', position.id);
+            }
+            const payload = await this.requestJson(token, url.toString());
+            if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.comments)) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            const match = payload.comments.find((value) => (0, vendor_shared_1.isRecord)(value) &&
+                (typeof value.id === 'string' || typeof value.id === 'number') &&
+                String(value.id) === normalizedCommentId);
+            if (match) {
+                const snapshot = this.normalizeTaskComment(match);
+                return {
+                    remoteId: snapshot.remoteId,
+                    authorRemoteId: snapshot.author.remoteId,
+                    createdAt: snapshot.createdAt,
+                    raw: match.comment ?? null,
+                    metadata: this.commentMetadata(match),
+                };
+            }
+            const last = payload.comments[payload.comments.length - 1];
+            const lastRecord = (0, vendor_shared_1.isRecord)(last) ? last : null;
+            if (!lastRecord) {
+                return null;
+            }
+            const nextDate = this.requiredTimestamp(lastRecord.date);
+            const nextId = typeof lastRecord.id === 'string' || typeof lastRecord.id === 'number'
+                ? String(lastRecord.id)
+                : null;
+            if (nextId === null) {
+                return null;
+            }
+            position = this.decodeCommentCursor(this.encodeCommentCursor(Date.parse(nextDate), nextId));
+        }
+        return null;
+    }
+    async deleteComment(credentials, _context, remoteTaskId, commentId) {
+        const token = this.requireToken(credentials);
+        this.validate.requiredTaskId(remoteTaskId);
+        const normalizedCommentId = this.validate.requiredIdentifier(commentId);
+        await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/comment/${encodeURIComponent(normalizedCommentId)}`, { method: 'DELETE' });
+    }
+    async updateOwnedComment(credentials, _context, remoteTaskId, commentId, document, metadata) {
+        const token = this.requireToken(credentials);
+        this.validate.requiredTaskId(remoteTaskId);
+        const normalizedCommentId = this.validate.requiredIdentifier(commentId);
+        const emitted = (0, clickup_comment_converter_2.richDocumentToClickUpCommentDelta)(document);
+        if (!emitted.ok) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/comment/${encodeURIComponent(normalizedCommentId)}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                comment: emitted.delta,
+                assignee: metadata.assignee,
+                resolved: metadata.resolved ?? false,
+                ...(metadata.groupAssignee !== null ? { group_assignee: metadata.groupAssignee } : {}),
+            }),
+        });
+    }
+    commentMetadata(raw) {
+        if (!(0, vendor_shared_1.isRecord)(raw)) {
+            return { assignee: null, resolved: null, groupAssignee: null };
+        }
+        const assignee = (0, vendor_shared_1.isRecord)(raw.assignee) ? raw.assignee.id : raw.assignee;
+        const groupAssignee = raw.group_assignee;
+        return {
+            assignee: typeof assignee === 'number' && Number.isSafeInteger(assignee)
+                ? assignee
+                : typeof assignee === 'string' && /^\d+$/.test(assignee)
+                    ? Number(assignee)
+                    : null,
+            resolved: typeof raw.resolved === 'boolean' ? raw.resolved : null,
+            groupAssignee: typeof groupAssignee === 'string' && groupAssignee ? groupAssignee : null,
+        };
+    }
+    async readDescription(credentials, _context, remoteTaskId) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const url = new URL(`${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}`);
+        url.searchParams.set('include_markdown_description', 'true');
+        const payload = await this.requestJson(token, url.toString());
+        if (!(0, vendor_shared_1.isRecord)(payload)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const markdown = payload.markdown_description;
+        if (markdown === null || markdown === undefined) {
+            return null;
+        }
+        if (typeof markdown !== 'string') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return markdown;
+    }
+    async writeDescription(credentials, _context, remoteTaskId, raw) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        if (typeof raw !== 'string' || !raw.trim()) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}`, {
+            method: 'PUT',
+            body: JSON.stringify({ markdown_description: raw }),
+        });
+    }
+    async verifyCredentials(credentials) {
+        const token = this.requireToken(credentials);
+        const payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/user`);
+        const dto = payload;
+        const remoteId = dto?.user?.id;
+        const displayName = dto?.user?.username;
+        if (typeof displayName !== 'string' || !displayName.trim()) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return {
+            provider: this.provider,
+            remoteId: this.validate.requiredIdentifier(remoteId),
+            displayName: displayName.trim(),
+        };
+    }
+    async getTaskDetail(credentials, _context, remoteTaskId) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const taskUrl = new URL(`${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}`);
+        taskUrl.searchParams.set('include_subtasks', 'true');
+        const payload = await this.requestJson(token, taskUrl.toString());
+        if (!(0, vendor_shared_1.isRecord)(payload) || !(0, vendor_shared_1.isRecord)(payload.status) || !(0, vendor_shared_1.isRecord)(payload.list)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const returnedId = this.validate.requiredIdentifier(payload.id);
+        if (returnedId !== taskId) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const scopeKey = this.validate.requiredIdentifier(payload.team_id);
+        const workAreaId = this.validate.requiredIdentifier(payload.list.id);
+        const description = this.boundedTaskDescription(payload.text_content);
+        const webUrl = this.requiredTaskUrl(payload.url);
+        const allowedStatuses = await this.loadAllowedStatuses(token, workAreaId);
+        const childResult = this.normalizeTaskSubtasks(payload.subtasks, taskId);
+        const customId = payload.custom_id;
+        if (customId !== null && customId !== undefined && typeof customId !== 'string') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return {
+            remoteId: returnedId,
+            remoteKey: typeof customId === 'string' && customId.trim() ? customId : returnedId,
+            title: this.validate.requiredString(payload.name),
+            description: description.value,
+            descriptionTruncated: description.truncated,
+            status: this.normalizeColumn(payload.status),
+            dueAt: this.optionalTimestamp(payload.due_date),
+            priority: this.normalizePriority(payload.priority),
+            subtasks: childResult.items,
+            subtasksTruncated: childResult.truncated,
+            taskTotalDurationMs: this.taskTotalDurationMs(payload.time_spent),
+            webUrl,
+            location: {
+                scopeKey,
+                workAreaId,
+                workAreaName: this.validate.requiredString(payload.list.name),
+            },
+            allowedStatuses,
+            actions: [
+                { action: 'change_status', supported: true },
+                { action: 'add_comment', supported: true },
+                { action: 'log_time', supported: true },
+            ],
+        };
+    }
+    async listTaskComments(credentials, context, remoteTaskId, cursor) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const position = cursor === null ? null : this.decodeCommentCursor(cursor);
+        const url = new URL(`${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}/comment`);
+        if (position) {
+            url.searchParams.set('start', String(position.date));
+            url.searchParams.set('start_id', position.id);
+        }
+        const payload = await this.requestJson(token, url.toString());
+        if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.comments)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        if (payload.comments.length > CLICKUP_COMMENT_PAGE_SIZE) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const comments = payload.comments.map((value) => {
+            const comment = this.normalizeTaskComment(value);
+            return this.enrichTaskComment(comment, value, taskId, cursor, context);
+        });
+        const last = comments[comments.length - 1];
+        return {
+            comments,
+            nextCursor: comments.length === CLICKUP_COMMENT_PAGE_SIZE && last
+                ? this.encodeCommentCursor(Date.parse(last.createdAt), last.remoteId)
+                : null,
+        };
+    }
+    enrichTaskComment(comment, raw, taskId, pageProof, context) {
+        const delta = (0, vendor_shared_1.isRecord)(raw) ? raw.comment : undefined;
+        const parsed = delta === undefined || delta === null ? null : (0, clickup_comment_converter_1.clickupCommentDeltaToRichDocument)(delta);
+        return {
+            ...comment,
+            owned: false,
+            rich: parsed === null
+                ? null
+                : parsed.supported
+                    ? { document: parsed.document, supported: true }
+                    : { supported: false, readOnlyReason: parsed.reason },
+            lookupToken: (0, external_comment_lookup_token_1.encodeExternalCommentLookupToken)({
+                v: 1,
+                provider: 'clickup',
+                connectionId: context.connectionId,
+                connectionGeneration: context.connectionGeneration,
+                taskId,
+                commentId: comment.remoteId,
+                pageProof,
+            }),
+        };
+    }
+    decodeCommentCursor(cursor) {
+        if (cursor.length > external_provider_models_1.MAX_TASK_COMMENT_CURSOR_LENGTH ||
+            !CLICKUP_COMMENT_CURSOR_PATTERN.test(cursor)) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        let decoded;
+        try {
+            decoded = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        }
+        catch {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        if (!(0, vendor_shared_1.isRecord)(decoded)) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        const id = decoded.id;
+        if (typeof id !== 'string' || !id.trim() || id.trim().length > external_provider_models_1.MAX_TASK_COMMENT_ID_LENGTH) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        const date = decoded.date;
+        if (typeof date !== 'number' || !Number.isSafeInteger(date) || date < 0) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        return { date, id: id.trim() };
+    }
+    encodeCommentCursor(date, id) {
+        return Buffer.from(JSON.stringify({ date, id }), 'utf8').toString('base64url');
+    }
+    normalizeTaskComment(value) {
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const remoteId = this.validate.requiredIdentifier(value.id);
+        if (remoteId.length > external_provider_models_1.MAX_TASK_COMMENT_ID_LENGTH) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const text = value.comment_text;
+        if (text !== null && text !== undefined && typeof text !== 'string') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const body = text ?? '';
+        return {
+            remoteId,
+            author: this.validate.commentAuthor(value.user, CLICKUP_COMMENT_AUTHOR),
+            body: body.slice(0, external_provider_models_1.MAX_TASK_COMMENT_BODY_LENGTH),
+            bodyTruncated: body.length > external_provider_models_1.MAX_TASK_COMMENT_BODY_LENGTH,
+            createdAt: this.requiredTimestamp(value.date),
+            updatedAt: null,
+        };
+    }
+    async changeTaskStatus(credentials, _context, remoteTaskId, input) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const status = this.validate.statusInput(input);
+        await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}`, {
+            method: 'PUT',
+            body: JSON.stringify({ status }),
+        });
+    }
+    async addTaskComment(credentials, _context, remoteTaskId, input) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        this.validate.commentInput(input);
+        await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}/comment`, {
+            method: 'POST',
+            body: JSON.stringify({ comment_text: input.text, notify_all: input.notifyAll }),
+        });
+    }
+    async loadTaskWorkspace(token, taskId) {
+        const task = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}`);
+        if (!(0, vendor_shared_1.isRecord)(task) || this.validate.requiredIdentifier(task.id) !== taskId) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return this.validate.requiredIdentifier(task.team_id);
+    }
+    async createTimeEntry(credentials, _context, remoteTaskId, input) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const startedAt = this.validate.timeEntryInput(input);
+        const workspaceId = await this.loadTaskWorkspace(token, taskId);
+        const body = {
+            start: startedAt,
+            duration: input.durationMs,
+        };
+        if (input.note !== null) {
+            body.description = input.note;
+        }
+        body.tid = taskId;
+        const payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/team/${encodeURIComponent(workspaceId)}/time_entries`, { method: 'POST', body: JSON.stringify(body) });
+        if (!(0, vendor_shared_1.isRecord)(payload) || !this.isDocumentedCreateReceipt(payload, taskId)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response', undefined, true);
+        }
+        return { remoteEntryId: this.optionalIdentifier(payload.id) };
+    }
+    isDocumentedCreateReceipt(payload, taskId) {
+        if (!this.isNumericValue(payload.start) || !this.isNumericValue(payload.duration)) {
+            return false;
+        }
+        if (!this.isNumericValue(payload.assignee) || typeof payload.billable !== 'boolean') {
+            return false;
+        }
+        if (!Array.isArray(payload.tags)) {
+            return false;
+        }
+        if (payload.description !== null &&
+            payload.description !== undefined &&
+            typeof payload.description !== 'string') {
+            return false;
+        }
+        const tid = this.optionalIdentifier(payload.tid);
+        return tid !== null && tid === taskId;
+    }
+    async readTimeEntryExact(credentials, _context, remoteTaskId, remoteEntryId) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const entryId = this.validate.requiredIdentifier(remoteEntryId);
+        const ownerId = await this.getCurrentOwnerRemoteId(credentials);
+        const workspaceId = await this.loadTaskWorkspace(token, taskId);
+        let payload;
+        try {
+            payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/team/${encodeURIComponent(workspaceId)}/time_entries/${encodeURIComponent(entryId)}`);
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.ClickUpProviderError && error.details?.reason === 'not_found') {
+                return null;
+            }
+            throw error;
+        }
+        const entry = this.singularTimeEntryBody(payload);
+        if (entry === null) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const remoteId = this.optionalIdentifier(entry.id);
+        if (remoteId === null || remoteId !== entryId) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const owner = (0, vendor_shared_1.isRecord)(entry.user) ? this.validate.requiredIdentifier(entry.user.id) : null;
+        if (owner === null) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return {
+            remoteId,
+            startedAt: new Date(this.numericValue(entry.start)).toISOString(),
+            durationMs: this.numericValue(entry.duration),
+            owned: owner === ownerId,
+        };
+    }
+    singularTimeEntryBody(payload) {
+        if (!(0, vendor_shared_1.isRecord)(payload)) {
+            return null;
+        }
+        if (!('data' in payload)) {
+            return payload;
+        }
+        const data = payload.data;
+        if ((0, vendor_shared_1.isRecord)(data)) {
+            return data;
+        }
+        if (Array.isArray(data) && data.length === 1) {
+            const only = data[0];
+            if ((0, vendor_shared_1.isRecord)(only)) {
+                return only;
+            }
+        }
+        return null;
+    }
+    async deleteTimeEntry(credentials, _context, remoteTaskId, remoteEntryId) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const entryId = this.validate.requiredIdentifier(remoteEntryId);
+        const workspaceId = await this.loadTaskWorkspace(token, taskId);
+        const payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/team/${encodeURIComponent(workspaceId)}/time_entries/${encodeURIComponent(entryId)}`, { method: 'DELETE' });
+        const entry = this.singularTimeEntryBody(payload);
+        if (entry === null) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response', undefined, true);
+        }
+        const remoteId = this.optionalIdentifier(entry.id);
+        if (remoteId !== entryId) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response', undefined, true);
+        }
+    }
+    async listOwnTimeEntryIdsInRange(credentials, _context, remoteTaskId, startedAfterMs, startedBeforeMs) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const ownerId = await this.getCurrentOwnerRemoteId(credentials);
+        const workspaceId = await this.loadTaskWorkspace(token, taskId);
+        const url = new URL(`${CLICKUP_ORIGIN}/api/v2/team/${encodeURIComponent(workspaceId)}/time_entries`);
+        url.searchParams.set('start_date', String(startedAfterMs));
+        url.searchParams.set('end_date', String(startedBeforeMs));
+        url.searchParams.set('task_id', taskId);
+        url.searchParams.append('assignee_ids[]', ownerId);
+        const payload = await this.requestJson(token, url.toString());
+        if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.data)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const ids = [];
+        for (const value of payload.data) {
+            if (!(0, vendor_shared_1.isRecord)(value)) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            ids.push(this.validate.requiredIdentifier(value.id));
+        }
+        return { ids, complete: false };
+    }
+    async assertTimeEntryDeletable(credentials, context, remoteTaskId, remoteEntryId) {
+        const now = Date.now();
+        const range = await this.listOwnTimeEntryIdsInRange(credentials, context, remoteTaskId, now - external_provider_models_1.TIME_ENTRY_HISTORY_WINDOW_DAYS * 86_400_000, now);
+        if (!range.ids.includes(remoteEntryId)) {
+            throw new external_provider_errors_1.ClickUpProviderError('not_found');
+        }
+    }
+    async getTaskTimeEntryHistory(credentials, _context, remoteTaskId) {
+        const token = this.requireToken(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const ownerId = await this.getCurrentOwnerRemoteId(credentials);
+        const task = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/task/${encodeURIComponent(taskId)}`);
+        if (!(0, vendor_shared_1.isRecord)(task) || this.validate.requiredIdentifier(task.id) !== taskId) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const workspaceId = this.validate.requiredIdentifier(task.team_id);
+        const now = Date.now();
+        const url = new URL(`${CLICKUP_ORIGIN}/api/v2/team/${encodeURIComponent(workspaceId)}/time_entries`);
+        url.searchParams.set('start_date', String(now - external_provider_models_1.TIME_ENTRY_HISTORY_WINDOW_DAYS * 86_400_000));
+        url.searchParams.set('end_date', String(now));
+        url.searchParams.set('task_id', taskId);
+        url.searchParams.append('assignee_ids[]', ownerId);
+        const payload = await this.requestJson(token, url.toString());
+        if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.data)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const entries = [];
+        let hasRunningTimer = false;
+        for (const value of payload.data) {
+            const normalized = this.normalizeTimeEntry(value, ownerId);
+            if (normalized.running) {
+                hasRunningTimer = true;
+                continue;
+            }
+            if (normalized.entry) {
+                entries.push(normalized.entry);
+            }
+        }
+        this.sortTimeEntries(entries);
+        return {
+            windowDays: external_provider_models_1.TIME_ENTRY_HISTORY_WINDOW_DAYS,
+            truncated: entries.length > external_provider_models_1.MAX_TIME_ENTRY_HISTORY_ENTRIES,
+            hasRunningTimer,
+            entries: entries.slice(0, external_provider_models_1.MAX_TIME_ENTRY_HISTORY_ENTRIES),
+        };
+    }
+    normalizeTimeEntry(value, ownerId) {
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const remoteId = this.validate.requiredIdentifier(value.id);
+        const duration = this.numericValue(value.duration);
+        if (!Number.isSafeInteger(duration)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        if (duration <= 0) {
+            return { entry: null, running: true };
+        }
+        const start = this.numericValue(value.start);
+        let startedAt;
+        try {
+            startedAt = new Date(start).toISOString();
+        }
+        catch {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const owner = (0, vendor_shared_1.isRecord)(value.user) ? this.validate.requiredIdentifier(value.user.id) : null;
+        if (owner === null) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        if (owner !== ownerId) {
+            return { entry: null, running: false };
+        }
+        const description = value.description;
+        if (description !== null && description !== undefined && typeof description !== 'string') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const note = description ?? '';
+        return {
+            entry: {
+                remoteId,
+                durationMs: duration,
+                startedAt,
+                note: note ? note.slice(0, external_provider_models_1.MAX_TIME_ENTRY_NOTE_LENGTH) : null,
+                noteTruncated: note.length > external_provider_models_1.MAX_TIME_ENTRY_NOTE_LENGTH,
+                canDelete: true,
+            },
+            running: false,
+        };
+    }
+    numericValue(value) {
+        const parsed = typeof value === 'number'
+            ? value
+            : typeof value === 'string' && value.trim()
+                ? Number(value)
+                : Number.NaN;
+        if (!Number.isFinite(parsed)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return parsed;
+    }
+    isNumericValue(value) {
+        if (typeof value === 'number') {
+            return Number.isFinite(value);
+        }
+        return typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value));
+    }
+    optionalIdentifier(value) {
+        if ((typeof value !== 'string' && typeof value !== 'number') ||
+            (typeof value === 'number' && !Number.isFinite(value)) ||
+            !String(value).trim()) {
+            return null;
+        }
+        return String(value).trim();
+    }
+    taskTotalDurationMs(value) {
+        if (value === null || value === undefined || value === '') {
+            return null;
+        }
+        const total = this.numericValue(value);
+        if (!Number.isSafeInteger(total) || total < 0) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return total;
+    }
+    sortTimeEntries(entries) {
+        entries.sort((left, right) => Date.parse(right.startedAt) - Date.parse(left.startedAt) ||
+            (0, vendor_shared_1.compareRemoteIds)(left.remoteId, right.remoteId));
+    }
+    async discoverMyWork(credentials, options) {
+        const account = await this.verifyCredentials(credentials);
+        const workspaces = await this.loadWorkspaces(credentials.token);
+        const now = Date.now();
+        const cutoff = now - vendor_shared_1.RECENT_COMPLETED_WINDOW_MS;
+        const tasks = new Map();
+        const workspacePages = await (0, vendor_shared_1.mapWithConcurrency)(workspaces, vendor_shared_1.VENDOR_DISCOVERY_CONCURRENCY, async (workspace) => {
+            const [active, completed] = await Promise.all([
+                this.loadTaskPages(credentials.token, workspace, account.remoteId, {
+                    includeCompleted: false,
+                    cutoff,
+                    now,
+                }),
+                options.includeCompleted
+                    ? this.loadTaskPages(credentials.token, workspace, account.remoteId, {
+                        includeCompleted: true,
+                        cutoff,
+                        now,
+                    })
+                    : Promise.resolve([]),
+            ]);
+            return [...active, ...completed];
+        });
+        for (const page of workspacePages) {
+            this.addTasks(tasks, page);
+        }
+        const enriched = await this.enrichWorkAreas(credentials.token, options, [...tasks.values()]);
+        return {
+            capabilities: { timeTrackingEnabled: true },
+            workAreas: enriched.workAreas,
+            tasks: enriched.tasks,
+            refreshedAt: new Date().toISOString(),
+        };
+    }
+    async loadWorkspaces(token) {
+        const payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/team`);
+        if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.teams)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return payload.teams.map((value) => {
+            if (!(0, vendor_shared_1.isRecord)(value)) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            const id = this.validate.requiredIdentifier(value.id);
+            const name = this.validate.requiredString(value.name);
+            return { id, name };
+        });
+    }
+    async loadTaskPages(token, workspace, ownerId, filter) {
+        const result = [];
+        for (let page = 0; page < CLICKUP_MAX_TASK_PAGES; page += 1) {
+            const url = new URL(`${CLICKUP_ORIGIN}/api/v2/team/${encodeURIComponent(workspace.id)}/task`);
+            url.searchParams.set('page', String(page));
+            url.searchParams.set('order_by', 'id');
+            url.searchParams.set('subtasks', 'true');
+            url.searchParams.append('assignees[]', ownerId);
+            url.searchParams.set('include_closed', String(filter.includeCompleted));
+            if (filter.includeCompleted) {
+                url.searchParams.set('date_done_gt', String(filter.cutoff));
+                url.searchParams.set('date_done_lt', String(filter.now));
+            }
+            const payload = await this.requestJson(token, url.toString());
+            if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.tasks)) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            if (payload.tasks.length > CLICKUP_TASK_PAGE_SIZE) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            for (const value of payload.tasks) {
+                const task = this.normalizeTask(value, workspace, ownerId);
+                if (!task) {
+                    continue;
+                }
+                if (filter.includeCompleted) {
+                    if (task.task.status.category !== 'completed' ||
+                        task.task.completedAt === null ||
+                        Date.parse(task.task.completedAt) < filter.cutoff ||
+                        Date.parse(task.task.completedAt) > filter.now) {
+                        continue;
+                    }
+                }
+                else if (task.task.status.category === 'completed') {
+                    continue;
+                }
+                result.push(task);
+            }
+            if (payload.tasks.length < CLICKUP_TASK_PAGE_SIZE) {
+                return result;
+            }
+        }
+        throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+    }
+    normalizeTask(value, workspace, ownerId) {
+        if (!(0, vendor_shared_1.isRecord)(value) ||
+            !(0, vendor_shared_1.isRecord)(value.status) ||
+            !(0, vendor_shared_1.isRecord)(value.list) ||
+            !Array.isArray(value.assignees)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const assignedToOwner = value.assignees.some((assignee) => (0, vendor_shared_1.isRecord)(assignee) &&
+            (typeof assignee.id === 'string' || typeof assignee.id === 'number') &&
+            String(assignee.id) === ownerId);
+        if (!assignedToOwner) {
+            return null;
+        }
+        const remoteId = this.validate.requiredIdentifier(value.id);
+        const statusType = this.validate.requiredString(value.status.type).toLowerCase();
+        const completedAt = this.optionalTimestamp(value.date_done ?? value.date_closed);
+        const workArea = {
+            remoteId: this.validate.requiredIdentifier(value.list.id),
+            scopeKey: workspace.id,
+            name: this.validate.requiredString(value.list.name),
+            kind: 'list',
+            description: null,
+            assignedTaskCount: 0,
+            hierarchy: [{ kind: 'workspace', remoteId: workspace.id, name: workspace.name }],
+            workflow: { isOverridden: false, columns: [] },
+            refresh: {
+                state: 'error',
+                refreshedAt: null,
+                retryable: true,
+                retryAt: null,
+            },
+        };
+        return {
+            workArea,
+            task: {
+                remoteId,
+                parentRemoteTaskId: this.optionalTaskParentId(value.parent),
+                title: this.validate.requiredString(value.name),
+                status: {
+                    remoteId: value.status.id === null || value.status.id === undefined
+                        ? null
+                        : this.validate.requiredIdentifier(value.status.id),
+                    name: this.validate.requiredString(value.status.status),
+                    category: this.classifyStatus(statusType),
+                },
+                updatedAt: this.requiredTimestamp(value.date_updated),
+                dueAt: this.optionalTimestamp(value.due_date),
+                completedAt,
+                webUrl: this.safeTaskUrl(value.url),
+            },
+        };
+    }
+    normalizeTaskSubtasks(value, parentRemoteTaskId) {
+        if (value === null || value === undefined) {
+            return { items: [], truncated: false };
+        }
+        if (!Array.isArray(value)) {
+            return { items: [], truncated: true };
+        }
+        const items = [];
+        let truncated = false;
+        for (const candidate of value) {
+            if (!(0, vendor_shared_1.isRecord)(candidate)) {
+                truncated = true;
+                continue;
+            }
+            const candidateParentId = this.optionalTaskParentId(candidate.parent);
+            if (candidateParentId === null) {
+                truncated = true;
+                continue;
+            }
+            if (candidateParentId !== parentRemoteTaskId) {
+                continue;
+            }
+            try {
+                items.push(this.normalizeTaskSubtask(candidate));
+            }
+            catch (error) {
+                if (!(error instanceof external_provider_errors_1.ClickUpProviderError)) {
+                    throw error;
+                }
+                truncated = true;
+            }
+        }
+        items.sort(vendor_shared_1.compareTaskSubtaskSummaries);
+        return {
+            items: items.slice(0, external_provider_models_1.MAX_TASK_DETAIL_SUBTASKS),
+            truncated: truncated || items.length > external_provider_models_1.MAX_TASK_DETAIL_SUBTASKS,
+        };
+    }
+    normalizeTaskSubtask(value) {
+        if (!(0, vendor_shared_1.isRecord)(value.status)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const remoteId = this.validate.requiredIdentifier(value.id);
+        const customId = value.custom_id;
+        if (customId !== null && customId !== undefined && typeof customId !== 'string') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return {
+            remoteId,
+            remoteKey: typeof customId === 'string' && customId.trim() ? customId.trim() : remoteId,
+            title: this.validate.requiredString(value.name),
+            status: {
+                remoteId: value.status.id === null || value.status.id === undefined
+                    ? null
+                    : this.validate.requiredIdentifier(value.status.id),
+                name: this.validate.requiredString(value.status.status),
+                category: this.classifyStatus(this.validate.requiredString(value.status.type).toLowerCase()),
+            },
+            webUrl: this.safeTaskUrl(value.url),
+        };
+    }
+    optionalTaskParentId(value) {
+        if (value === null || value === undefined || value === '') {
+            return null;
+        }
+        try {
+            return this.validate.requiredIdentifier(value);
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.ClickUpProviderError) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    addTasks(tasks, additions) {
+        for (const item of additions) {
+            const taskKey = `${item.workArea.scopeKey}:${item.task.remoteId}`;
+            if (!tasks.has(taskKey)) {
+                tasks.set(taskKey, item);
+            }
+        }
+    }
+    async enrichWorkAreas(token, options, tasks) {
+        const groups = new Map();
+        for (const item of tasks) {
+            const key = this.workAreaKey(item.workArea);
+            const existing = groups.get(key);
+            if (existing) {
+                existing.assignedTaskCount += 1;
+            }
+            else {
+                groups.set(key, { base: item.workArea, assignedTaskCount: 1 });
+            }
+        }
+        const groupEntries = [...groups];
+        const enriched = await (0, vendor_shared_1.mapWithConcurrency)(groupEntries, vendor_shared_1.VENDOR_DISCOVERY_CONCURRENCY, ([, group]) => this.loadWorkAreaMetadata(token, options, group.base, group.assignedTaskCount));
+        const enrichedByKey = new Map(groupEntries.map(([key], index) => [key, enriched[index]]));
+        return {
+            workAreas: [...enrichedByKey.values()],
+            tasks: tasks.map((item) => ({
+                workArea: enrichedByKey.get(this.workAreaKey(item.workArea)),
+                task: item.task,
+            })),
+        };
+    }
+    async loadWorkAreaMetadata(token, options, base, assignedTaskCount) {
+        const cacheKey = JSON.stringify([
+            options.connectionId,
+            options.connectionGeneration,
+            base.scopeKey,
+            base.remoteId,
+        ]);
+        const cached = this.listMetadataCache.get(cacheKey);
+        const now = Date.now();
+        if (cached && now - cached.fetchedAt <= vendor_shared_1.WORK_AREA_METADATA_TTL_MS) {
+            return (0, vendor_shared_1.materializeWorkArea)(cached.value, assignedTaskCount, {
+                state: 'fresh',
+                refreshedAt: new Date(cached.fetchedAt).toISOString(),
+                retryable: false,
+                retryAt: null,
+            });
+        }
+        try {
+            const payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/list/${encodeURIComponent(base.remoteId)}`);
+            const metadata = this.normalizeListMetadata(payload, base);
+            this.listMetadataCache.set(cacheKey, { value: metadata, fetchedAt: now });
+            return (0, vendor_shared_1.materializeWorkArea)(metadata, assignedTaskCount, {
+                state: 'fresh',
+                refreshedAt: new Date(now).toISOString(),
+                retryable: false,
+                retryAt: null,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof external_provider_errors_1.ClickUpProviderError)) {
+                throw error;
+            }
+            const retryAt = (0, vendor_shared_1.vendorRetryAt)(error);
+            if (cached) {
+                return (0, vendor_shared_1.materializeWorkArea)(cached.value, assignedTaskCount, {
+                    state: 'stale',
+                    refreshedAt: new Date(cached.fetchedAt).toISOString(),
+                    retryable: true,
+                    retryAt,
+                });
+            }
+            return {
+                ...base,
+                assignedTaskCount,
+                refresh: { state: 'error', refreshedAt: null, retryable: true, retryAt },
+            };
+        }
+    }
+    normalizeListMetadata(value, base) {
+        if (!(0, vendor_shared_1.isRecord)(value) ||
+            !(0, vendor_shared_1.isRecord)(value.space) ||
+            !Array.isArray(value.statuses) ||
+            typeof value.override_statuses !== 'boolean') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const remoteId = this.validate.requiredIdentifier(value.id);
+        if (remoteId !== base.remoteId) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const hierarchy = [
+            ...base.hierarchy.filter((location) => location.kind === 'workspace'),
+            {
+                kind: 'space',
+                remoteId: this.validate.requiredIdentifier(value.space.id),
+                name: this.validate.requiredString(value.space.name),
+            },
+        ];
+        if (value.folder !== null && value.folder !== undefined) {
+            if (!(0, vendor_shared_1.isRecord)(value.folder)) {
+                throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+            }
+            hierarchy.push({
+                kind: 'folder',
+                remoteId: this.validate.requiredIdentifier(value.folder.id),
+                name: this.validate.requiredString(value.folder.name),
+            });
+        }
+        const columns = this.sortedColumns(value.statuses);
+        return {
+            remoteId,
+            scopeKey: base.scopeKey,
+            name: this.validate.requiredString(value.name),
+            kind: 'list',
+            description: this.optionalDescription(value.content),
+            hierarchy,
+            workflow: { isOverridden: value.override_statuses, columns },
+        };
+    }
+    normalizeColumn(value) {
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        if ((typeof value.orderindex !== 'string' && typeof value.orderindex !== 'number') ||
+            (typeof value.orderindex === 'string' && !value.orderindex.trim())) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const position = Number(value.orderindex);
+        if (!Number.isFinite(position)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return {
+            remoteId: value.id === null || value.id === undefined
+                ? null
+                : this.validate.requiredIdentifier(value.id),
+            name: this.requiredExactString(value.status),
+            color: this.requiredExactString(value.color),
+            category: this.classifyStatus(this.validate.requiredString(value.type).toLowerCase()),
+            position,
+        };
+    }
+    async loadAllowedStatuses(token, workAreaId) {
+        const payload = await this.requestJson(token, `${CLICKUP_ORIGIN}/api/v2/list/${encodeURIComponent(workAreaId)}`);
+        if (!(0, vendor_shared_1.isRecord)(payload) ||
+            this.validate.requiredIdentifier(payload.id) !== workAreaId ||
+            !Array.isArray(payload.statuses)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return this.sortedColumns(payload.statuses).map((column) => ({
+            actionValue: column.name,
+            ...(column.remoteId !== null ? { remoteStatusIds: [column.remoteId] } : {}),
+            remoteId: column.remoteId,
+            name: column.name,
+            color: column.color,
+            category: column.category,
+            position: column.position,
+        }));
+    }
+    sortedColumns(statuses) {
+        return statuses
+            .map((status, index) => ({ column: this.normalizeColumn(status), index }))
+            .sort((left, right) => left.column.position - right.column.position || left.index - right.index)
+            .map(({ column }) => column);
+    }
+    boundedTaskDescription(value) {
+        if (value === null || value === undefined || value === '') {
+            return { value: null, truncated: false };
+        }
+        if (typeof value !== 'string') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return {
+            value: value.slice(0, external_provider_models_1.MAX_TASK_DETAIL_TEXT_LENGTH),
+            truncated: value.length > external_provider_models_1.MAX_TASK_DETAIL_TEXT_LENGTH,
+        };
+    }
+    normalizePriority(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return {
+            name: this.requiredExactString(value.priority),
+            color: this.requiredExactString(value.color),
+        };
+    }
+    requiredTaskUrl(value) {
+        const url = this.safeTaskUrl(value);
+        if (!url) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return url;
+    }
+    workAreaKey(workArea) {
+        return JSON.stringify([workArea.scopeKey, workArea.remoteId]);
+    }
+    optionalDescription(value) {
+        if (value === null || value === undefined || value === '') {
+            return null;
+        }
+        if (typeof value !== 'string') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return value;
+    }
+    requiredExactString(value) {
+        if (typeof value !== 'string' || !value.trim()) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return value;
+    }
+    requireToken(credentials) {
+        if (credentials.provider !== this.provider || !credentials.token.trim()) {
+            throw new external_provider_errors_1.ClickUpProviderError('request_rejected');
+        }
+        return credentials.token;
+    }
+    classifyStatus(value) {
+        if (value === 'open' || value === 'custom') {
+            return 'active';
+        }
+        if (value === 'done' || value === 'closed') {
+            return 'completed';
+        }
+        return 'unknown';
+    }
+    requiredTimestamp(value) {
+        const timestamp = this.optionalTimestamp(value);
+        if (!timestamp) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        return timestamp;
+    }
+    optionalTimestamp(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        if ((typeof value === 'string' && !value.trim()) || !Number.isFinite(Number(value))) {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+        const milliseconds = Number(value);
+        try {
+            return new Date(milliseconds).toISOString();
+        }
+        catch {
+            throw new external_provider_errors_1.ClickUpProviderError('invalid_response');
+        }
+    }
+    safeTaskUrl(value) {
+        return (0, external_task_source_1.normalizeExternalTaskSourceUrl)(this.provider, value);
+    }
+    async requestJson(token, url, request = {}) {
+        try {
+            return await this.http.requestJson({
+                url,
+                allowedOrigins: [CLICKUP_ORIGIN],
+                ...(request.method ? { method: request.method } : {}),
+                ...(request.body !== undefined ? { body: request.body } : {}),
+                headers: {
+                    accept: 'application/json',
+                    authorization: token,
+                    ...(request.body !== undefined ? { 'content-type': 'application/json' } : {}),
+                },
+            });
+        }
+        catch (error) {
+            throw (0, vendor_shared_1.mapVendorTransportError)(error, (reason, retryAt, dispatched) => new external_provider_errors_1.ClickUpProviderError(reason, retryAt, dispatched));
+        }
+    }
+    async requestNoContent(token, url, request) {
+        try {
+            await this.http.requestNoContent({
+                url,
+                allowedOrigins: [CLICKUP_ORIGIN],
+                ...request,
+                headers: {
+                    accept: 'application/json',
+                    authorization: token,
+                    ...(request.body === undefined ? {} : { 'content-type': 'application/json' }),
+                },
+            });
+        }
+        catch (error) {
+            throw (0, vendor_shared_1.mapVendorTransportError)(error, (reason, retryAt, dispatched) => new external_provider_errors_1.ClickUpProviderError(reason, retryAt, dispatched));
+        }
+    }
+};
+exports.ClickUpExternalTaskProvider = ClickUpExternalTaskProvider;
+exports.ClickUpExternalTaskProvider = ClickUpExternalTaskProvider = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [safe_vendor_http_client_1.SafeVendorHttpClient])
+], ClickUpExternalTaskProvider);
+//# sourceMappingURL=clickup-external-task.provider.js.map