@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/sync/syncApplyHandlers.js

@@ -1,10 +1,285 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createHash } from 'crypto';
-import { compareWorkspaceMutationOrdering } from './workspaceSyncSurface.js';
+import { normalizeBinaryAssetDeleteSyncPayload, normalizeBinaryAssetSyncPayload, normalizeDocumentDeleteSyncPayload, normalizeDocumentSyncPayload, } from './contentSyncPayload.js';
+import { normalizeAiProfileSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDeleteSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, } from './collaborationSyncPayload.js';
+import { normalizeInitiativeSyncPayload, normalizeTaxonomySyncPayload, normalizeWorkstreamSyncPayload, } from './planningSyncPayload.js';
+import { normalizeTaskSyncPayload, taskSyncPayloadToCoreTask, } from './taskSyncPayload.js';
+import { compareWorkspaceMutationOrdering, getTaskMutationTieBreak, getTaskMutationWatermark } from './workspaceSyncSurface.js';
+function createIncomingApplyModel() {
+    return {
+        taskMutations: {
+            upserts: [],
+            deletes: new Map(),
+        },
+        planning: {
+            incomingTaxonomies: null,
+            incomingTaxonomyState: null,
+            incomingTaxonomiesUpdatedAt: '',
+            incomingInitiatives: new Map(),
+            incomingWorkstreams: new Map(),
+        },
+        profiles: {
+            incomingAiProfiles: new Map(),
+        },
+        content: {
+            incomingDocuments: [],
+            incomingDocumentDeletes: new Map(),
+            incomingAssets: [],
+            incomingAssetDeletes: new Map(),
+        },
+        collaboration: {
+            incomingDocumentReviewSessions: new Map(),
+            incomingDocumentReviewSessionDeletes: new Map(),
+            incomingDocumentReviewComments: new Map(),
+            incomingDocumentReviewCommentDeletes: new Map(),
+            incomingAnnotatedAttachmentSessions: new Map(),
+            incomingAnnotatedAttachmentSessionDeletes: new Map(),
+        },
+        taskActivity: {
+            incomingTaskEvents: new Map(),
+        },
+    };
+}
 export function resolveSyncConflictOrdering(incomingWatermark, existingWatermark, incomingTieBreak, existingTieBreak) {
     return compareWorkspaceMutationOrdering(String(incomingWatermark || '').trim(), String(existingWatermark || '').trim(), String(incomingTieBreak || '').trim(), String(existingTieBreak || '').trim());
 }
+function shouldSkipTaskClassification(op) {
+    return (op === 'delete'
+        || op === 'initiative-upsert'
+        || op === 'workstream-upsert'
+        || op === 'document-upsert'
+        || op === 'document-delete'
+        || op === 'asset-upsert'
+        || op === 'asset-delete'
+        || op === 'document-review-session-upsert'
+        || op === 'document-review-session-delete'
+        || op === 'document-review-comment-upsert'
+        || op === 'document-review-comment-delete'
+        || op === 'annotated-attachment-session-upsert'
+        || op === 'annotated-attachment-session-delete');
+}
+function recordTaskReferenceNumberMismatch(input) {
+    const { core, workspaceId, task, recordSyncDiagnostic, } = input;
+    const taskId = String(task?.id || '').trim();
+    const incomingReferenceNumber = Number.isFinite(Number(task?.referenceNumber))
+        ? Math.max(1, Math.floor(Number(task?.referenceNumber)))
+        : null;
+    if (!incomingReferenceNumber)
+        return false;
+    const existingTask = core.resolveTaskIdentifier(`T-${incomingReferenceNumber}`, workspaceId);
+    if (!existingTask || existingTask.id === taskId)
+        return false;
+    recordSyncDiagnostic(workspaceId, 'apply', 'Detected task reference number mismatch during normal sync.', {
+        source: 'tasks.referenceNumber.mismatch',
+        taskId: taskId || null,
+        taskTitle: typeof task?.title === 'string' ? task.title.trim() || null : null,
+        existingTaskId: existingTask.id,
+        existingTaskTitle: existingTask.title || null,
+        referenceLabel: `T-${incomingReferenceNumber}`,
+        existingReferenceNumber: existingTask.referenceNumber ?? incomingReferenceNumber,
+        incomingReferenceNumber
+    });
+    return true;
+}
+export function classifyWorkspaceSyncChanges(input) {
+    const { workspaceId, incomingChanges, normalizeWorkspaceSyncDocumentPath, normalizeTaskAssetPath, normalizeIncomingAiProfileSurfaceType, normalizeTaskEventSyncPayload, recordSyncDiagnostic, } = input;
+    const model = createIncomingApplyModel();
+    for (const change of incomingChanges) {
+        const raw = change;
+        const op = String(raw.op || '').trim().toLowerCase();
+        if (op === 'taxonomy-upsert') {
+            const taxonomy = normalizeTaxonomySyncPayload(raw);
+            if (taxonomy?.taxonomyState)
+                model.planning.incomingTaxonomyState = taxonomy.taxonomyState;
+            if (Array.isArray(taxonomy?.taxonomies))
+                model.planning.incomingTaxonomies = taxonomy.taxonomies;
+            if (taxonomy?.updatedAt)
+                model.planning.incomingTaxonomiesUpdatedAt = taxonomy.updatedAt;
+            continue;
+        }
+        if (op === 'initiative-upsert') {
+            const initiative = normalizeInitiativeSyncPayload(raw.initiative, String(raw.updatedAt || raw.watermark || '').trim());
+            if (initiative)
+                model.planning.incomingInitiatives.set(initiative.id, initiative);
+            continue;
+        }
+        if (op === 'workstream-upsert') {
+            const workstream = normalizeWorkstreamSyncPayload(raw.workstream, String(raw.updatedAt || raw.watermark || '').trim());
+            if (workstream)
+                model.planning.incomingWorkstreams.set(workstream.id, workstream);
+            continue;
+        }
+        if (op === 'ai-profile-upsert') {
+            const profile = normalizeAiProfileSyncPayload(raw.profile, workspaceId, normalizeIncomingAiProfileSurfaceType, 'apply.aiProfileUpsert');
+            const profileId = String(profile?.id || '').trim();
+            if (profileId && profile) {
+                const profileWorkspaceId = String(profile.workspaceId || '').trim();
+                if (profileWorkspaceId && profileWorkspaceId !== workspaceId) {
+                    recordSyncDiagnostic(workspaceId, 'apply', `Rejected ai-profile-upsert for profile ${profileId}: workspace mismatch (expected ${workspaceId}, got ${profileWorkspaceId}).`, {
+                        source: 'apply.aiProfileWorkspaceMismatch',
+                        workspaceId,
+                        profileId,
+                        expectedWorkspaceId: workspaceId,
+                        receivedWorkspaceId: profileWorkspaceId
+                    });
+                    continue;
+                }
+                model.profiles.incomingAiProfiles.set(profileId, {
+                    ...profile,
+                    workspaceId,
+                    createdAt: profile.createdAt || String(raw.updatedAt || raw.watermark || '').trim(),
+                    updatedAt: profile.updatedAt || String(raw.updatedAt || raw.watermark || '').trim(),
+                });
+            }
+            continue;
+        }
+        if (op === 'document-upsert') {
+            const document = normalizeDocumentSyncPayload(raw, normalizeWorkspaceSyncDocumentPath);
+            if (document)
+                model.content.incomingDocuments.push(document);
+            continue;
+        }
+        if (op === 'document-delete') {
+            const deletedDocument = normalizeDocumentDeleteSyncPayload(raw, normalizeWorkspaceSyncDocumentPath);
+            if (deletedDocument)
+                model.content.incomingDocumentDeletes.set(deletedDocument.path, deletedDocument.deletedAt);
+            continue;
+        }
+        if (op === 'asset-upsert') {
+            const asset = normalizeBinaryAssetSyncPayload(raw, normalizeTaskAssetPath);
+            if (asset)
+                model.content.incomingAssets.push(asset);
+            continue;
+        }
+        if (op === 'asset-delete') {
+            const deletedAsset = normalizeBinaryAssetDeleteSyncPayload(raw, normalizeTaskAssetPath);
+            if (deletedAsset)
+                model.content.incomingAssetDeletes.set(deletedAsset.path, deletedAsset.deletedAt);
+            continue;
+        }
+        if (op === 'document-review-session-upsert') {
+            const session = normalizeDocumentReviewSessionSyncPayload(raw.session, String(raw.updatedAt || raw.watermark || '').trim());
+            if (session)
+                model.collaboration.incomingDocumentReviewSessions.set(session.id, session);
+            continue;
+        }
+        if (op === 'document-review-session-delete') {
+            const deletedSession = normalizeDeleteSyncPayload(raw, 'sessionId');
+            if (deletedSession)
+                model.collaboration.incomingDocumentReviewSessionDeletes.set(deletedSession.id, deletedSession.deletedAt);
+            continue;
+        }
+        if (op === 'document-review-comment-upsert') {
+            const comment = normalizeDocumentReviewCommentSyncPayload(raw.comment, { sourceWatermark: String(raw.updatedAt || raw.watermark || '').trim() });
+            if (comment)
+                model.collaboration.incomingDocumentReviewComments.set(comment.id, comment);
+            continue;
+        }
+        if (op === 'document-review-comment-delete') {
+            const deletedComment = normalizeDeleteSyncPayload(raw, 'commentId');
+            if (deletedComment)
+                model.collaboration.incomingDocumentReviewCommentDeletes.set(deletedComment.id, deletedComment.deletedAt);
+            continue;
+        }
+        if (op === 'annotated-attachment-session-upsert') {
+            const session = normalizeAnnotatedAttachmentSessionSyncPayload(raw.session, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
+            if (session)
+                model.collaboration.incomingAnnotatedAttachmentSessions.set(session.id, session);
+            continue;
+        }
+        if (op === 'annotated-attachment-session-delete') {
+            const deletedSession = normalizeDeleteSyncPayload(raw, 'sessionId');
+            if (deletedSession)
+                model.collaboration.incomingAnnotatedAttachmentSessionDeletes.set(deletedSession.id, deletedSession.deletedAt);
+            continue;
+        }
+        if (op === 'task-event-upsert') {
+            const event = normalizeTaskEventSyncPayload(raw.event, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
+            if (event)
+                model.taskActivity.incomingTaskEvents.set(event.id, event);
+            continue;
+        }
+        if (op !== 'delete')
+            continue;
+        const task = normalizeTaskSyncPayload(raw.task);
+        const deleteTaskId = String(raw.taskId || raw.id || task?.id || '').trim();
+        if (deleteTaskId) {
+            model.taskMutations.deletes.set(deleteTaskId, String(raw.deletedAt || raw.watermark || new Date().toISOString()).trim());
+        }
+    }
+    for (const change of incomingChanges) {
+        const raw = change;
+        const op = String(raw.op || '').trim().toLowerCase();
+        if (shouldSkipTaskClassification(op))
+            continue;
+        const task = normalizeTaskSyncPayload(raw.task);
+        if (!task)
+            continue;
+        model.taskMutations.upserts.push({
+            archived: raw.archived === true || task.isArchived === true,
+            task,
+        });
+    }
+    return model;
+}
+export function prepareTaskSyncSnapshotApply(input) {
+    const { core, workspaceId, taskMutations, recordSyncDiagnostic, } = input;
+    const prepared = {
+        tasks: [],
+        archived: [],
+    };
+    for (const mutation of taskMutations.upserts) {
+        const task = mutation.task;
+        const taskId = String(task.id || '').trim();
+        recordTaskReferenceNumberMismatch({
+            core,
+            workspaceId,
+            task: task,
+            recordSyncDiagnostic,
+        });
+        const deleteWatermark = taskId ? String(taskMutations.deletes.get(taskId) || '').trim() : '';
+        if (taskId && deleteWatermark) {
+            const compareAgainstDelete = resolveSyncConflictOrdering(deleteWatermark, String(task.updatedAt || task.createdAt || '').trim(), `delete:${taskId}`, getTaskMutationTieBreak(task, mutation.archived));
+            if (compareAgainstDelete >= 0)
+                continue;
+        }
+        if (mutation.archived)
+            prepared.archived.push(task);
+        else
+            prepared.tasks.push(task);
+    }
+    return prepared;
+}
+export function applyTaskSyncDeletes(input) {
+    const { core, workspaceId, taskMutations, recordSyncDiagnostic, } = input;
+    for (const [taskId, deleteWatermark] of taskMutations.deletes.entries()) {
+        try {
+            const existingTask = core.getTask(taskId, workspaceId);
+            if (existingTask) {
+                const compareAgainstExisting = resolveSyncConflictOrdering(deleteWatermark, getTaskMutationWatermark(existingTask), `delete:${taskId}`, getTaskMutationTieBreak(existingTask, Boolean(existingTask.isArchived)));
+                if (compareAgainstExisting < 0)
+                    continue;
+            }
+            core.deleteTaskForSync(taskId, workspaceId, { persistBackup: false });
+        }
+        catch (error) {
+            recordSyncDiagnostic(workspaceId, 'apply', 'Failed to delete task during sync apply.', {
+                source: 'apply.deleteTask',
+                taskId,
+                error: String(error?.message || error || '')
+            });
+        }
+    }
+    return taskMutations.deletes.size;
+}
+export function applyPreparedTaskSyncSnapshot(input) {
+    const { core, workspaceId, prepared, } = input;
+    return core.applyWorkspaceSyncSnapshot({
+        tasks: prepared.tasks.map(taskSyncPayloadToCoreTask),
+        archived: prepared.archived.map(taskSyncPayloadToCoreTask)
+    }, workspaceId);
+}
 export function applyPlanningSyncChanges(input) {
     const { core, workspaceId, incomingInitiatives, incomingWorkstreams, incomingTaxonomies, incomingTaxonomyState, incomingTaxonomiesUpdatedAt, workspaceTaxonomySyncMeta, recordSyncDiagnostic, } = input;
     if (incomingInitiatives.size > 0) {
@@ -107,6 +382,10 @@ export function applyAiProfileAndMemberSyncChanges(input) {
                     username: profile.username,
                     icon: profile.icon,
                     color: profile.color,
+                    description: profile.description ?? null,
+                    role: profile.role ?? null,
+                    provider: profile.provider ?? null,
+                    model: profile.model ?? null,
                     surfaceType: profile.surfaceType,
                     providerMetadata: profile.providerMetadata,
                     createdAt: profile.createdAt,
@@ -150,21 +429,29 @@ export function applyAiProfileAndMemberSyncChanges(input) {
     }
 }
 export async function applyContentSyncChanges(input) {
-    const { core, workspaceId, incomingDocuments, incomingDocumentDeletes, incomingAssets, incomingAssetDeletes, basePath, hasObjectStorageClient, hasDocumentSyncMetadataDrift, hasBinaryAssetSyncMetadataDrift, writeWorkspaceSyncDocument, deleteWorkspaceSyncDocument, writeWorkspaceSyncBinaryAsset, deleteWorkspaceSyncBinaryAsset, getExistingBinaryAsset, recordSyncDiagnostic, options, } = input;
+    const { core, workspaceId, incomingDocuments, incomingDocumentDeletes, incomingAssets, incomingAssetDeletes, basePath, hasObjectStorageClient, hasDocumentSyncMetadataDrift, hasBinaryAssetSyncMetadataDrift, getExistingDocument, writeWorkspaceSyncDocument, deleteWorkspaceSyncDocument, writeWorkspaceSyncBinaryAsset, deleteWorkspaceSyncBinaryAsset, getExistingBinaryAsset, recordSyncDiagnostic, options, } = input;
     if (incomingDocuments.length > 0) {
         for (const doc of incomingDocuments) {
             try {
                 const existingDoc = core.getDocumentWatermark(workspaceId, doc.path);
+                const existingDocFallback = getExistingDocument ? getExistingDocument(doc.path, workspaceId) : null;
+                const localDocumentPath = path.resolve(basePath, doc.path);
+                const localDocumentHash = !hasObjectStorageClient() && fs.existsSync(localDocumentPath)
+                    ? createHash('sha256').update(fs.readFileSync(localDocumentPath, 'utf8')).digest('hex')
+                    : '';
                 const incomingHash = createHash('sha256').update(String(doc.content || '')).digest('hex');
-                const existingUpdatedAt = String(existingDoc?.updatedAt || '').trim();
-                const existingHash = String(existingDoc?.contentHash || '').trim();
+                const existingUpdatedAt = String(existingDoc?.updatedAt || existingDocFallback?.updatedAt || '').trim();
+                const existingHash = String(existingDoc?.contentHash || localDocumentHash || existingDocFallback?.contentHash || '').trim();
                 const compare = resolveSyncConflictOrdering(doc.updatedAt, existingUpdatedAt, incomingHash, existingHash);
                 const metadataDrift = hasDocumentSyncMetadataDrift(workspaceId, doc, options);
                 if (compare < 0)
                     continue;
                 if (compare === 0 && existingHash === incomingHash && !metadataDrift)
                     continue;
-                await writeWorkspaceSyncDocument(basePath, doc, workspaceId, options);
+                await writeWorkspaceSyncDocument(basePath, doc, workspaceId, {
+                    ...options,
+                    allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true || existingHash !== incomingHash
+                });
             }
             catch (error) {
                 recordSyncDiagnostic(workspaceId, 'apply', 'Failed to apply synced document change.', {
@@ -190,18 +477,27 @@ export async function applyContentSyncChanges(input) {
     if (incomingAssets.length > 0) {
         for (const asset of incomingAssets) {
             try {
+                const localAssetPath = path.resolve(basePath, asset.path);
                 const existing = getExistingBinaryAsset(asset.path, workspaceId);
                 const incomingHash = createHash('sha256').update(Buffer.from(String(asset.contentBase64 || ''), 'base64')).digest('hex');
+                const localFileMissing = !hasObjectStorageClient() && !fs.existsSync(localAssetPath);
+                const localAssetHash = !hasObjectStorageClient() && !localFileMissing
+                    ? createHash('sha256').update(fs.readFileSync(localAssetPath)).digest('hex')
+                    : '';
                 const existingUpdatedAt = String(existing?.updatedAt || '').trim();
-                const existingHash = String(existing?.contentSha256 || '').trim();
-                const localFileMissing = !hasObjectStorageClient() && !fs.existsSync(path.resolve(basePath, asset.path));
+                const existingHash = String(localAssetHash || existing?.contentSha256 || '').trim();
                 const compare = resolveSyncConflictOrdering(asset.updatedAt, existingUpdatedAt, incomingHash, existingHash);
                 const metadataDrift = hasBinaryAssetSyncMetadataDrift(workspaceId, asset, options);
                 if (compare < 0)
                     continue;
                 if (compare === 0 && existingHash === incomingHash && !localFileMissing && !metadataDrift)
                     continue;
-                await writeWorkspaceSyncBinaryAsset(basePath, asset, workspaceId, options);
+                await writeWorkspaceSyncBinaryAsset(basePath, asset, workspaceId, {
+                    ...options,
+                    allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true
+                        || existingHash !== incomingHash
+                        || localFileMissing
+                });
             }
             catch (error) {
                 recordSyncDiagnostic(workspaceId, 'apply', 'Failed to apply synced asset change.', {
@@ -443,3 +739,69 @@ export function applyCollaborationSyncChanges(input) {
         }
     }
 }
+export function applyTaskActivitySyncChanges(input) {
+    const { core, workspaceId, incomingTaskEvents, recordSyncDiagnostic, createSyncRouteError, } = input;
+    if (incomingTaskEvents.size <= 0)
+        return;
+    for (const event of incomingTaskEvents.values()) {
+        try {
+            const taskId = String(event.taskId || '').trim();
+            if (!taskId)
+                continue;
+            const existingTask = core.getTask(taskId, workspaceId);
+            if (!existingTask) {
+                recordSyncDiagnostic(workspaceId, 'apply', 'Skipped task event during sync apply because the task does not exist locally.', {
+                    source: 'apply.taskEventMissingTask',
+                    eventId: event.id,
+                    taskId,
+                });
+                continue;
+            }
+            const existing = core.listTaskEvents(taskId, workspaceId).find((entry) => entry.id === event.id) || null;
+            const incomingTieBreak = createHash('sha256')
+                .update(JSON.stringify({
+                taskId,
+                action: event.action,
+                actor: event.actor,
+                actorType: event.actorType,
+                details: event.details ?? {},
+            }))
+                .digest('hex');
+            const existingTieBreak = existing
+                ? createHash('sha256')
+                    .update(JSON.stringify({
+                    taskId: existing.taskId,
+                    action: existing.action,
+                    actor: existing.actor,
+                    actorType: existing.actorType,
+                    details: existing.details ?? {},
+                }))
+                    .digest('hex')
+                : '';
+            const compare = resolveSyncConflictOrdering(event.createdAt, String(existing?.createdAt || '').trim(), incomingTieBreak, existingTieBreak);
+            if (compare < 0)
+                continue;
+            core.upsertTaskEventForSync({
+                id: event.id,
+                taskId,
+                workspaceId,
+                action: event.action,
+                actor: event.actor,
+                actorType: event.actorType,
+                details: event.details,
+                createdAt: event.createdAt,
+            });
+        }
+        catch (error) {
+            const details = {
+                source: 'apply.taskEventUpsert',
+                eventId: event.id,
+                taskId: event.taskId,
+                error: String(error?.message || error || ''),
+                errorCode: String(error?.code || '').trim() || null
+            };
+            recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert task event during sync apply.', details);
+            throw createSyncRouteError(`Failed to persist task event ${event.id} during sync apply: ${String(error?.message || error || 'Unknown error')}`, details, { code: 'TASK_EVENT_SYNC_APPLY_FAILED', statusCode: 500 });
+        }
+    }
+}

package/dist/sync/syncApplyHandlers.test.d.ts

@@ -0,0 +1 @@
+export {};