devchain-cli 0.20.3 → 0.22.0

package/dist/server/modules/external-integrations/my-work/external-edit-session.service.js

@@ -0,0 +1,776 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalEditSessionService = void 0;
+const common_1 = require("@nestjs/common");
+const error_types_1 = require("../../../common/errors/error-types");
+const storage_interface_1 = require("../../storage/interfaces/storage.interface");
+const external_provider_errors_1 = require("../errors/external-provider.errors");
+const external_task_provider_registry_1 = require("../external-task-provider.registry");
+const external_rich_document_1 = require("../models/external-rich-document");
+const external_rich_capabilities_1 = require("../models/external-rich-capabilities");
+const external_comment_lookup_token_1 = require("../models/external-comment-lookup-token");
+const jira_adf_converter_1 = require("../adapters/rich/jira-adf-converter");
+const clickup_markdown_converter_1 = require("../adapters/rich/clickup-markdown-converter");
+const clickup_comment_converter_1 = require("../adapters/rich/clickup-comment-converter");
+const external_edit_session_store_1 = require("../sessions/external-edit-session.store");
+const provider_operation_gate_1 = require("../sessions/provider-operation-gate");
+function isUnknownOutcome(error) {
+    return (error instanceof external_provider_errors_1.ExternalProviderError &&
+        error.details?.dispatched === true &&
+        (error.details?.reason === 'timeout' ||
+            error.details?.reason === 'unavailable' ||
+            error.details?.reason === 'invalid_response'));
+}
+function isProviderNotFound(error) {
+    return error instanceof external_provider_errors_1.ExternalProviderError && error.details?.reason === 'not_found';
+}
+let ExternalEditSessionService = class ExternalEditSessionService {
+    storage;
+    providers;
+    gate;
+    store;
+    capabilities;
+    constructor(storage, providers, gate, store, capabilities = external_rich_capabilities_1.EXTERNAL_RICH_CAPABILITIES) {
+        this.storage = storage;
+        this.providers = providers;
+        this.gate = gate;
+        this.store = store;
+        this.capabilities = capabilities;
+    }
+    async readRichDescription(provider, remoteTaskId) {
+        const adapter = this.providers.get(provider);
+        if (!adapter.descriptionEdit) {
+            throw this.unsupported(provider);
+        }
+        const { connection, credentials } = await this.loadStableConnection(provider);
+        const raw = await adapter.descriptionEdit.readDescription(credentials, this.context(connection), remoteTaskId);
+        const parsed = this.parseProviderDescription(provider, raw);
+        if (!parsed.supported) {
+            return {
+                document: null,
+                fingerprint: null,
+                supported: false,
+                readOnlyReason: 'unsupported_content',
+                canEdit: false,
+                canDeleteOwnedComments: this.capabilities.ownedDelete,
+            };
+        }
+        return {
+            document: parsed.document,
+            fingerprint: (0, external_rich_document_1.richDocumentFingerprint)(parsed.document),
+            supported: true,
+            readOnlyReason: null,
+            canEdit: this.capabilities.richEdit,
+            canDeleteOwnedComments: this.capabilities.ownedDelete,
+        };
+    }
+    async createDescriptionSession(provider, remoteTaskId) {
+        this.requireRichEditCapability();
+        const adapter = this.providers.get(provider);
+        if (!adapter.descriptionEdit) {
+            throw this.unsupported(provider);
+        }
+        const { connection, credentials } = await this.loadStableConnection(provider);
+        const raw = await adapter.descriptionEdit.readDescription(credentials, this.context(connection), remoteTaskId);
+        const parsed = this.parseProviderDescription(provider, raw);
+        if (!parsed.supported) {
+            throw new error_types_1.ValidationError('This task description contains unsupported content.', {
+                provider,
+                reason: 'unsupported_content',
+            });
+        }
+        const created = this.store.create({
+            kind: 'description_edit',
+            provider,
+            connectionId: connection.id,
+            connectionGeneration: connection.generation,
+            scopeKey: this.scopeKey(connection),
+            remoteTaskId,
+            remoteCommentId: null,
+            baseline: {
+                document: parsed.document,
+                fingerprint: (0, external_rich_document_1.richDocumentFingerprint)(parsed.document),
+            },
+            providerMetadata: { lookupToken: null, ownerRemoteId: '' },
+        });
+        if (!created.ok) {
+            throw this.storeFailure(created.reason);
+        }
+        return this.store.view(created.value);
+    }
+    async createCommentEditSession(provider, remoteTaskId, commentId, lookupToken) {
+        this.requireRichEditCapability();
+        const { session } = await this.createCommentSession(provider, remoteTaskId, commentId, lookupToken, 'comment_edit');
+        return session;
+    }
+    async createCommentDeleteSession(provider, remoteTaskId, commentId, pageProof) {
+        this.requireOwnedDeleteCapability();
+        const { session } = await this.createCommentSession(provider, remoteTaskId, commentId, pageProof, 'comment_delete');
+        return session;
+    }
+    async touchSession(sessionId) {
+        const touched = this.store.touch(sessionId);
+        if (!touched.ok) {
+            throw this.sessionFailure(touched.reason);
+        }
+        return this.store.view(touched.value);
+    }
+    async saveSession(sessionId, payload, expectedRevision) {
+        const canonical = (0, external_rich_document_1.canonicalizeRichDocument)(payload);
+        if (canonical === null) {
+            throw new error_types_1.ValidationError('The payload is outside the supported rich content set.', {
+                reason: 'unsupported_content',
+            });
+        }
+        const fingerprint = (0, external_rich_document_1.richDocumentFingerprint)(canonical);
+        const initial = this.store.get(sessionId);
+        if (!initial.ok) {
+            return this.writeRejected(null, this.writeFailure(initial.reason));
+        }
+        const kind = initial.value.kind;
+        if (kind === 'comment_delete') {
+            throw new error_types_1.ValidationError('The session does not support content saves.', {
+                reason: 'wrong_session_kind',
+            });
+        }
+        this.requireRichEditCapability();
+        const provider = initial.value.provider;
+        let phase;
+        try {
+            phase = await this.gate.run(provider, () => this.saveDispatchPhase(sessionId, provider, kind, canonical, fingerprint, expectedRevision));
+        }
+        catch (error) {
+            if (error instanceof error_types_1.BusyError) {
+                return this.writeRejected(this.currentView(sessionId), 'operation_busy');
+            }
+            throw error;
+        }
+        if (phase.phase === 'rejected') {
+            return this.writeRejected(this.currentView(sessionId), phase.reason);
+        }
+        if (phase.phase === 'outcome_unknown') {
+            const view = this.currentView(sessionId);
+            return view === null
+                ? this.writeRejected(null, 'session_not_found')
+                : { outcome: 'outcome_unknown', session: view };
+        }
+        return this.postWriteVerification(sessionId, provider, kind, fingerprint, canonical);
+    }
+    async saveDispatchPhase(sessionId, provider, kind, canonical, fingerprint, expectedRevision) {
+        const adapter = this.providers.get(provider);
+        const connection = await this.storage.getIntegrationConnection(provider);
+        const session = this.store.get(sessionId);
+        if (!session.ok) {
+            return { phase: 'rejected', reason: this.writeFailure(session.reason) };
+        }
+        if (!connection ||
+            connection.provider !== provider ||
+            connection.id !== session.value.connectionId ||
+            connection.generation !== session.value.connectionGeneration) {
+            this.store.invalidate(sessionId);
+            return { phase: 'rejected', reason: 'connection_superseded' };
+        }
+        const context = this.context(connection);
+        let fresh;
+        let commentMetadata = null;
+        if (kind === 'description_edit') {
+            if (!adapter.descriptionEdit) {
+                throw this.unsupported(provider);
+            }
+            const raw = await adapter.descriptionEdit.readDescription((await this.storage.getIntegrationConnectionCredentials(provider)), context, session.value.remoteTaskId);
+            const parsed = this.parseProviderDescription(provider, raw);
+            if (!parsed.supported) {
+                this.store.applyVerifyOutcome(sessionId, 'diverged');
+                return { phase: 'rejected', reason: 'diverged' };
+            }
+            fresh = { fingerprint: (0, external_rich_document_1.richDocumentFingerprint)(parsed.document), document: parsed.document };
+        }
+        else {
+            if (!adapter.ownedMutations) {
+                throw this.unsupported(provider);
+            }
+            const token = this.sessionLookupToken(session.value.providerMetadata.lookupToken ?? '');
+            if (token === null ||
+                token.provider !== provider ||
+                token.connectionId !== connection.id ||
+                token.connectionGeneration !== connection.generation ||
+                token.taskId !== session.value.remoteTaskId ||
+                token.commentId !== session.value.remoteCommentId) {
+                this.store.invalidate(sessionId);
+                return { phase: 'rejected', reason: 'connection_superseded' };
+            }
+            const snapshot = await adapter.ownedMutations.findComment((await this.storage.getIntegrationConnectionCredentials(provider)), context, session.value.remoteTaskId, session.value.remoteCommentId, token.pageProof);
+            if (snapshot === null) {
+                this.store.invalidate(sessionId);
+                return { phase: 'rejected', reason: 'target_gone' };
+            }
+            if (snapshot.authorRemoteId === null ||
+                snapshot.authorRemoteId !== session.value.providerMetadata.ownerRemoteId) {
+                this.store.applyVerifyOutcome(sessionId, 'diverged');
+                return { phase: 'rejected', reason: 'diverged' };
+            }
+            const parsed = this.parseProviderComment(provider, snapshot.raw);
+            if (!parsed.supported) {
+                this.store.applyVerifyOutcome(sessionId, 'diverged');
+                return { phase: 'rejected', reason: 'diverged' };
+            }
+            fresh = { fingerprint: (0, external_rich_document_1.richDocumentFingerprint)(parsed.document), document: parsed.document };
+            commentMetadata = snapshot.metadata;
+        }
+        if (fresh.fingerprint !== session.value.baseline?.fingerprint) {
+            this.store.applyVerifyOutcome(sessionId, 'diverged');
+            return { phase: 'rejected', reason: 'diverged' };
+        }
+        if (session.value.state === 'outcome_unknown') {
+            const retry = this.store.beginRetryDispatch(sessionId, fingerprint, expectedRevision);
+            if (!retry.ok) {
+                return { phase: 'rejected', reason: this.writeFailure(retry.reason) };
+            }
+        }
+        else if (session.value.state === 'editable') {
+            const dispatch = this.store.beginDispatch(sessionId, fingerprint, expectedRevision);
+            if (!dispatch.ok) {
+                return { phase: 'rejected', reason: this.writeFailure(dispatch.reason) };
+            }
+        }
+        else {
+            return { phase: 'rejected', reason: 'session_not_editable' };
+        }
+        if (kind === 'description_edit') {
+            const emit = provider === 'jira' ? (0, jira_adf_converter_1.richDocumentToAdf)(canonical) : (0, clickup_markdown_converter_1.richDocumentToMarkdown)(canonical);
+            if ('ok' in emit && !emit.ok) {
+                this.store.revertDispatch(sessionId);
+                return { phase: 'rejected', reason: 'unsupported_content' };
+            }
+            const raw = 'ok' in emit && 'markdown' in emit ? emit.markdown : emit;
+            try {
+                await adapter.descriptionEdit.writeDescription((await this.storage.getIntegrationConnectionCredentials(provider)), context, session.value.remoteTaskId, raw);
+            }
+            catch (error) {
+                if (isUnknownOutcome(error)) {
+                    return { phase: 'outcome_unknown' };
+                }
+                this.store.revertDispatch(sessionId);
+                throw error;
+            }
+        }
+        else {
+            try {
+                await adapter.ownedMutations.updateOwnedComment((await this.storage.getIntegrationConnectionCredentials(provider)), context, session.value.remoteTaskId, session.value.remoteCommentId, canonical, commentMetadata);
+            }
+            catch (error) {
+                if (isUnknownOutcome(error)) {
+                    return { phase: 'outcome_unknown' };
+                }
+                this.store.revertDispatch(sessionId);
+                throw error;
+            }
+        }
+        const saved = this.store.markSavedUnverified(sessionId);
+        if (!saved.ok) {
+            return { phase: 'outcome_unknown' };
+        }
+        return { phase: 'dispatched' };
+    }
+    async postWriteVerification(sessionId, provider, kind, pendingFingerprint, canonical) {
+        const session = this.store.get(sessionId);
+        if (!session.ok) {
+            return this.writeRejected(null, this.writeFailure(session.reason));
+        }
+        const read = await this.freshContentFingerprint(provider, kind, session.value);
+        if (read.generationChanged) {
+            this.store.invalidate(sessionId);
+            return { outcome: 'saved_unverified', session: this.currentView(sessionId) };
+        }
+        if (!read.ok) {
+            return { outcome: 'saved_unverified', session: this.currentView(sessionId) };
+        }
+        if (read.fingerprint === pendingFingerprint) {
+            const committed = this.store.applyVerifyOutcome(sessionId, 'new_payload', {
+                document: canonical,
+                fingerprint: pendingFingerprint,
+            });
+            if (committed.ok) {
+                return {
+                    outcome: 'saved',
+                    revision: committed.value.revision,
+                    session: this.store.view(committed.value),
+                };
+            }
+        }
+        else if (read.fingerprint !== session.value.baseline?.fingerprint) {
+            this.store.applyVerifyOutcome(sessionId, 'diverged');
+        }
+        return { outcome: 'saved_unverified', session: this.currentView(sessionId) };
+    }
+    async freshContentFingerprint(provider, kind, session) {
+        const adapter = this.providers.get(provider);
+        const before = await this.storage.getIntegrationConnection(provider);
+        if (!before ||
+            before.provider !== provider ||
+            before.id !== session.connectionId ||
+            before.generation !== session.connectionGeneration) {
+            return { ok: false, fingerprint: null, generationChanged: true };
+        }
+        let fingerprint = null;
+        try {
+            if (kind === 'description_edit') {
+                if (!adapter.descriptionEdit) {
+                    throw this.unsupported(provider);
+                }
+                const raw = await adapter.descriptionEdit.readDescription((await this.storage.getIntegrationConnectionCredentials(provider)), this.context(before), session.remoteTaskId);
+                const parsed = this.parseProviderDescription(provider, raw);
+                fingerprint = parsed.supported ? (0, external_rich_document_1.richDocumentFingerprint)(parsed.document) : null;
+            }
+            else {
+                if (!adapter.ownedMutations) {
+                    throw this.unsupported(provider);
+                }
+                const token = this.sessionLookupToken(session.providerMetadata.lookupToken ?? '');
+                const snapshot = token === null
+                    ? null
+                    : await adapter.ownedMutations.findComment((await this.storage.getIntegrationConnectionCredentials(provider)), this.context(before), session.remoteTaskId, session.remoteCommentId, token.pageProof);
+                if (snapshot !== null) {
+                    const parsed = this.parseProviderComment(provider, snapshot.raw);
+                    fingerprint = parsed.supported ? (0, external_rich_document_1.richDocumentFingerprint)(parsed.document) : null;
+                }
+            }
+        }
+        catch {
+            return { ok: false, fingerprint: null, generationChanged: false };
+        }
+        const after = await this.storage.getIntegrationConnection(provider);
+        if (!after ||
+            after.provider !== provider ||
+            after.id !== session.connectionId ||
+            after.generation !== session.connectionGeneration) {
+            return { ok: false, fingerprint: null, generationChanged: true };
+        }
+        return { ok: fingerprint !== null, fingerprint, generationChanged: false };
+    }
+    async reloadSession(sessionId) {
+        const session = this.store.get(sessionId);
+        if (!session.ok) {
+            throw this.sessionFailure(session.reason);
+        }
+        if (session.value.kind === 'comment_delete') {
+            throw new error_types_1.ValidationError('The session does not support reload.', {
+                reason: 'wrong_session_kind',
+            });
+        }
+        this.requireRichEditCapability();
+        const provider = session.value.provider;
+        const { connection, credentials } = await this.loadStableConnection(provider);
+        if (connection.id !== session.value.connectionId) {
+            this.store.invalidate(sessionId);
+            throw new error_types_1.ValidationError('The connection was replaced; the session is invalid.', {
+                reason: 'connection_superseded',
+            });
+        }
+        if (session.value.kind === 'description_edit') {
+            const adapter = this.providers.get(provider);
+            if (!adapter.descriptionEdit) {
+                throw this.unsupported(provider);
+            }
+            const raw = await adapter.descriptionEdit.readDescription(credentials, this.context(connection), session.value.remoteTaskId);
+            const parsed = this.parseProviderDescription(provider, raw);
+            if (!parsed.supported) {
+                this.store.applyVerifyOutcome(sessionId, 'diverged');
+                return { status: 'unsupported', session: this.currentView(sessionId) };
+            }
+            const reloaded = this.store.commitReload(sessionId, {
+                document: parsed.document,
+                fingerprint: (0, external_rich_document_1.richDocumentFingerprint)(parsed.document),
+            });
+            if (!reloaded.ok) {
+                throw this.sessionFailure(reloaded.reason);
+            }
+            return { status: 'reloaded', session: this.store.view(reloaded.value) };
+        }
+        const adapter = this.providers.get(provider);
+        if (!adapter.ownedMutations) {
+            throw this.unsupported(provider);
+        }
+        const token = this.sessionLookupToken(session.value.providerMetadata.lookupToken ?? '');
+        if (token === null) {
+            this.store.invalidate(sessionId);
+            return { status: 'unsupported', session: this.currentView(sessionId) };
+        }
+        const snapshot = await adapter.ownedMutations.findComment(credentials, this.context(connection), session.value.remoteTaskId, session.value.remoteCommentId, token.pageProof);
+        if (snapshot === null) {
+            const gone = this.store.markDeleted(sessionId);
+            return { status: 'gone', session: gone.ok ? this.store.view(gone.value) : null };
+        }
+        if (snapshot.authorRemoteId === null ||
+            snapshot.authorRemoteId !== session.value.providerMetadata.ownerRemoteId) {
+            this.store.applyVerifyOutcome(sessionId, 'diverged');
+            return { status: 'unsupported', session: this.currentView(sessionId) };
+        }
+        const parsed = this.parseProviderComment(provider, snapshot.raw);
+        if (!parsed.supported) {
+            this.store.applyVerifyOutcome(sessionId, 'diverged');
+            return { status: 'unsupported', session: this.currentView(sessionId) };
+        }
+        const reloaded = this.store.commitReload(sessionId, {
+            document: parsed.document,
+            fingerprint: (0, external_rich_document_1.richDocumentFingerprint)(parsed.document),
+        });
+        if (!reloaded.ok) {
+            throw this.sessionFailure(reloaded.reason);
+        }
+        return { status: 'reloaded', session: this.store.view(reloaded.value) };
+    }
+    async verifySession(sessionId) {
+        const session = this.store.get(sessionId);
+        if (!session.ok) {
+            return { session: null, remoteState: null, reason: this.verifyFailure(session.reason) };
+        }
+        if (session.value.kind === 'comment_delete') {
+            return this.verifyDeleteSession(session.value);
+        }
+        const read = await this.freshContentFingerprint(session.value.provider, session.value.kind, session.value);
+        if (read.generationChanged) {
+            this.store.invalidate(sessionId);
+            return this.verifyResult(sessionId, 'diverged');
+        }
+        if (!read.ok) {
+            return this.verifyResult(sessionId, null);
+        }
+        const pending = session.value.pendingWrite?.fingerprint ?? null;
+        if (pending !== null && read.fingerprint === pending) {
+            const applied = this.store.applyVerifyOutcome(sessionId, 'new_payload', {
+                document: null,
+                fingerprint: pending,
+            });
+            return this.verifyResult(sessionId, applied.ok ? 'new_payload' : null);
+        }
+        if (read.fingerprint === session.value.baseline?.fingerprint) {
+            if (session.value.state === 'editable') {
+                return this.verifyResult(sessionId, 'old_baseline');
+            }
+            const applied = this.store.applyVerifyOutcome(sessionId, 'old_baseline');
+            return this.verifyResult(sessionId, applied.ok ? 'old_baseline' : null);
+        }
+        const applied = this.store.applyVerifyOutcome(sessionId, 'diverged');
+        return this.verifyResult(sessionId, applied.ok ? 'diverged' : null);
+    }
+    async executeCommentDelete(sessionId) {
+        this.requireOwnedDeleteCapability();
+        const session = this.store.get(sessionId);
+        if (!session.ok) {
+            return {
+                outcome: 'rejected',
+                reason: this.deleteFailure(session.reason),
+                session: null,
+            };
+        }
+        if (session.value.kind !== 'comment_delete') {
+            throw new error_types_1.ValidationError('The session does not support comment deletion.', {
+                reason: 'wrong_session_kind',
+            });
+        }
+        const provider = session.value.provider;
+        const adapter = this.providers.get(provider);
+        if (!adapter.ownedMutations) {
+            throw this.unsupported(provider);
+        }
+        try {
+            return await this.gate.run(provider, async () => {
+                const connection = await this.storage.getIntegrationConnection(provider);
+                if (!connection ||
+                    connection.provider !== provider ||
+                    connection.id !== session.value.connectionId ||
+                    connection.generation !== session.value.connectionGeneration) {
+                    this.store.invalidate(sessionId);
+                    return this.deleteRejected(this.currentView(sessionId), 'connection_superseded');
+                }
+                const token = this.sessionLookupToken(session.value.providerMetadata.lookupToken ?? '');
+                if (token === null ||
+                    token.provider !== provider ||
+                    token.connectionId !== connection.id ||
+                    token.connectionGeneration !== connection.generation ||
+                    token.taskId !== session.value.remoteTaskId ||
+                    token.commentId !== session.value.remoteCommentId) {
+                    this.store.invalidate(sessionId);
+                    return this.deleteRejected(this.currentView(sessionId), 'connection_superseded');
+                }
+                const preflight = this.store.get(sessionId);
+                if (!preflight.ok) {
+                    return this.deleteRejected(null, this.deleteFailure(preflight.reason));
+                }
+                const deleteFingerprint = `comment_delete:${session.value.remoteCommentId}`;
+                if (preflight.value.state === 'outcome_unknown') {
+                    const retry = this.store.beginRetryDispatch(sessionId, deleteFingerprint, preflight.value.revision);
+                    if (!retry.ok) {
+                        return this.deleteRejected(this.currentView(sessionId), this.deleteFailure(retry.reason));
+                    }
+                }
+                else if (preflight.value.state === 'editable') {
+                    const dispatch = this.store.beginDispatch(sessionId, deleteFingerprint, preflight.value.revision);
+                    if (!dispatch.ok) {
+                        return this.deleteRejected(this.currentView(sessionId), this.deleteFailure(dispatch.reason));
+                    }
+                }
+                else {
+                    return this.deleteRejected(this.currentView(sessionId), this.deleteFailure('session_not_editable'));
+                }
+                try {
+                    await adapter.ownedMutations.deleteComment((await this.storage.getIntegrationConnectionCredentials(provider)), this.context(connection), session.value.remoteTaskId, session.value.remoteCommentId);
+                }
+                catch (error) {
+                    if (isProviderNotFound(error)) {
+                        const deleted = this.store.markDeleted(sessionId);
+                        return {
+                            outcome: 'already_deleted',
+                            session: this.store.view(deleted.ok ? deleted.value : session.value),
+                        };
+                    }
+                    if (isUnknownOutcome(error)) {
+                        return { outcome: 'outcome_unknown', session: this.currentView(sessionId) };
+                    }
+                    this.store.invalidate(sessionId);
+                    return this.deleteRejected(this.currentView(sessionId), 'delete_rejected');
+                }
+                const deleted = this.store.markDeleted(sessionId);
+                return {
+                    outcome: 'deleted',
+                    session: this.store.view(deleted.ok ? deleted.value : session.value),
+                };
+            });
+        }
+        catch (error) {
+            if (error instanceof error_types_1.BusyError) {
+                return this.deleteRejected(this.currentView(sessionId), 'operation_busy');
+            }
+            throw error;
+        }
+    }
+    async createCommentSession(provider, remoteTaskId, commentId, lookupProof, kind) {
+        const adapter = this.providers.get(provider);
+        if (!adapter.ownedMutations) {
+            throw this.unsupported(provider);
+        }
+        const { connection, credentials } = await this.loadStableConnection(provider);
+        const [ownerRemoteId, snapshot] = await Promise.all([
+            adapter.ownedMutations.getCurrentOwnerRemoteId(credentials),
+            adapter.ownedMutations.findComment(credentials, this.context(connection), remoteTaskId, commentId, lookupProof),
+        ]);
+        if (snapshot === null) {
+            throw new error_types_1.ValidationError('The comment could not be found.', {
+                provider,
+                reason: 'comment_not_found',
+            });
+        }
+        if (snapshot.authorRemoteId === null || snapshot.authorRemoteId !== ownerRemoteId) {
+            throw new error_types_1.ValidationError('Only comments you authored can be changed.', {
+                provider,
+                reason: 'not_owned',
+            });
+        }
+        let baseline = null;
+        if (kind === 'comment_edit') {
+            const parsed = this.parseProviderComment(provider, snapshot.raw);
+            if (!parsed.supported) {
+                throw new error_types_1.ValidationError('The comment contains unsupported content.', {
+                    provider,
+                    reason: 'unsupported_content',
+                });
+            }
+            baseline = {
+                document: parsed.document,
+                fingerprint: (0, external_rich_document_1.richDocumentFingerprint)(parsed.document),
+            };
+        }
+        const lookupToken = (0, external_comment_lookup_token_1.encodeExternalCommentLookupToken)({
+            v: 1,
+            provider,
+            connectionId: connection.id,
+            connectionGeneration: connection.generation,
+            taskId: remoteTaskId,
+            commentId,
+            pageProof: lookupProof,
+        });
+        const created = this.store.create({
+            kind,
+            provider,
+            connectionId: connection.id,
+            connectionGeneration: connection.generation,
+            scopeKey: this.scopeKey(connection),
+            remoteTaskId,
+            remoteCommentId: commentId,
+            baseline,
+            providerMetadata: { lookupToken, ownerRemoteId },
+        });
+        if (!created.ok) {
+            throw this.storeFailure(created.reason);
+        }
+        return { session: this.store.view(created.value) };
+    }
+    parseProviderDescription(provider, raw) {
+        const parsed = provider === 'jira' ? (0, jira_adf_converter_1.adfToRichDocument)(raw) : (0, clickup_markdown_converter_1.markdownToRichDocument)(raw);
+        return parsed.supported ? { supported: true, document: parsed.document } : { supported: false };
+    }
+    parseProviderComment(provider, raw) {
+        const parsed = provider === 'jira' ? (0, jira_adf_converter_1.adfToRichDocument)(raw) : (0, clickup_comment_converter_1.clickupCommentDeltaToRichDocument)(raw);
+        return parsed.supported ? { supported: true, document: parsed.document } : { supported: false };
+    }
+    sessionLookupToken(value) {
+        const token = (0, external_comment_lookup_token_1.decodeExternalCommentLookupToken)(value);
+        return token;
+    }
+    requireRichEditCapability() {
+        if (!this.capabilities.richEdit) {
+            throw new error_types_1.ValidationError('Rich external editing is disabled by the capability gate.', {
+                reason: 'capability_no_go',
+            });
+        }
+    }
+    requireOwnedDeleteCapability() {
+        if (!this.capabilities.ownedDelete) {
+            throw new error_types_1.ValidationError('Owned comment deletion is disabled by the capability gate.', {
+                reason: 'capability_no_go',
+            });
+        }
+    }
+    async loadStableConnection(provider) {
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const before = await this.storage.getIntegrationConnection(provider);
+            if (!before || before.provider !== provider) {
+                throw this.notConnected(provider);
+            }
+            const credentials = await this.storage.getIntegrationConnectionCredentials(provider);
+            const after = await this.storage.getIntegrationConnection(provider);
+            if (!credentials ||
+                credentials.provider !== provider ||
+                !after ||
+                after.provider !== provider) {
+                throw this.notConnected(provider);
+            }
+            if (before.id === after.id && before.generation === after.generation) {
+                return { connection: after, credentials };
+            }
+        }
+        throw new error_types_1.BusyError('Integration connection changed during the operation.', {
+            provider,
+            reason: 'connection_changed',
+        });
+    }
+    currentView(sessionId) {
+        const session = this.store.get(sessionId);
+        return session.ok ? this.store.view(session.value) : null;
+    }
+    verifyResult(sessionId, remoteState) {
+        const session = this.store.get(sessionId);
+        return {
+            session: session.ok ? this.store.view(session.value) : null,
+            remoteState,
+            reason: null,
+        };
+    }
+    async verifyDeleteSession(session) {
+        const adapter = this.providers.get(session.provider);
+        if (!adapter.ownedMutations) {
+            throw this.unsupported(session.provider);
+        }
+        const token = this.sessionLookupToken(session.providerMetadata.lookupToken ?? '');
+        if (token === null) {
+            this.store.invalidate(session.sessionId);
+            return this.verifyResult(session.sessionId, 'diverged');
+        }
+        const { connection, credentials } = await this.loadStableConnection(session.provider);
+        if (connection.id !== session.connectionId) {
+            this.store.invalidate(session.sessionId);
+            return this.verifyResult(session.sessionId, 'diverged');
+        }
+        const snapshot = await adapter.ownedMutations.findComment(credentials, this.context(connection), session.remoteTaskId, session.remoteCommentId, token.pageProof);
+        if (snapshot === null) {
+            const deleted = this.store.markDeleted(session.sessionId);
+            return this.verifyResult(deleted.ok ? deleted.value.sessionId : session.sessionId, 'gone');
+        }
+        if (snapshot.authorRemoteId !== session.providerMetadata.ownerRemoteId) {
+            const diverged = this.store.applyVerifyOutcome(session.sessionId, 'diverged');
+            return this.verifyResult(diverged.ok ? diverged.value.sessionId : session.sessionId, 'diverged');
+        }
+        if (session.state === 'outcome_unknown' || session.state === 'saved_unverified') {
+            const stillPresent = this.store.applyVerifyOutcome(session.sessionId, 'old_baseline');
+            return this.verifyResult(stillPresent.ok ? stillPresent.value.sessionId : session.sessionId, 'old_baseline');
+        }
+        return this.verifyResult(session.sessionId, 'old_baseline');
+    }
+    writeRejected(session, reason) {
+        return { outcome: 'pre_dispatch_rejected', reason, session };
+    }
+    deleteRejected(session, reason) {
+        return { outcome: 'rejected', reason, session };
+    }
+    writeFailure(reason) {
+        if (reason === 'session_not_found' || reason === 'session_expired') {
+            return reason;
+        }
+        if (reason === 'revision_conflict') {
+            return reason;
+        }
+        return 'session_not_editable';
+    }
+    deleteFailure(reason) {
+        if (reason === 'session_not_found' || reason === 'session_expired') {
+            return reason;
+        }
+        return 'session_not_editable';
+    }
+    verifyFailure(reason) {
+        return reason === 'session_expired' ? 'session_expired' : 'session_not_found';
+    }
+    sessionFailure(reason) {
+        return new error_types_1.ValidationError('The edit session is no longer available.', { reason });
+    }
+    storeFailure(reason) {
+        return new error_types_1.ValidationError('The edit session could not be created.', {
+            reason: reason === 'baseline_too_large' ? 'baseline_too_large' : 'store_limit_exceeded',
+        });
+    }
+    notConnected(provider) {
+        return new error_types_1.ValidationError('Connect the integration before editing.', {
+            provider,
+            reason: 'not_connected',
+        });
+    }
+    unsupported(provider) {
+        return new error_types_1.ValidationError('The provider does not support this operation.', {
+            provider,
+            reason: 'unsupported_capability',
+        });
+    }
+    context(connection) {
+        return {
+            connectionId: connection.id,
+            connectionGeneration: connection.generation,
+        };
+    }
+    scopeKey(connection) {
+        return connection.id;
+    }
+};
+exports.ExternalEditSessionService = ExternalEditSessionService;
+exports.ExternalEditSessionService = ExternalEditSessionService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
+    __param(4, (0, common_1.Optional)()),
+    __param(4, (0, common_1.Inject)(external_rich_capabilities_1.EXTERNAL_RICH_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [Object, external_task_provider_registry_1.ExternalTaskProviderRegistry,
+        provider_operation_gate_1.ProviderOperationGate,
+        external_edit_session_store_1.ExternalEditSessionStore, Object])
+], ExternalEditSessionService);
+//# sourceMappingURL=external-edit-session.service.js.map