@taskforcehq/taskforce 0.3.168

package/dist/sync/syncService.js

@@ -0,0 +1,423 @@
+import { applyLocalWorkspaceChanges, handshakeWorkspace, pullWorkspaceChanges, provisionWorkspace, pullUserSettings, pushUserSettings, pushWorkspaceChanges } from './cloudSyncApi';
+import { encryptDocument, decryptDocument } from './encryptionService';
+function asObjectRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+export async function ensureCloudWorkspaceReadyForSyncService(input) {
+    if (!input.cloudAuthConfigured)
+        return { success: false, error: 'Cloud auth endpoint is not configured.' };
+    if (input.runtimeMode !== 'local')
+        return { success: false, error: 'Workspace sync is only available in local runtime.' };
+    if (!input.isAuthenticated)
+        return { success: false, error: 'Authentication required.' };
+    try {
+        let handshakeResult = await handshakeWorkspace(input.resolveCloudAuthUrl, input.workspaceId);
+        if (handshakeResult.ok)
+            return { success: true, provisioned: false };
+        const data = asObjectRecord(handshakeResult.data);
+        if (handshakeResult.status === 401) {
+            return {
+                success: false,
+                statusCode: 401,
+                error: String(data.error || 'Authentication required for workspace sync.')
+            };
+        }
+        if (handshakeResult.status === 429) {
+            return {
+                success: false,
+                statusCode: 429,
+                retryAfterMs: handshakeResult.retryAfterMs,
+                error: String(data.error || 'Workspace sync rate limited. Please retry later.')
+            };
+        }
+        if (handshakeResult.status === 409 && data.code === 'WORKSPACE_ID_MISMATCH') {
+            const provisionResult = await provisionWorkspace(input.resolveCloudAuthUrl, {
+                workspaceId: input.workspaceId,
+                name: input.workspaceName || input.workspaceId
+            });
+            if (!provisionResult.ok) {
+                const provisionError = asObjectRecord(provisionResult.data);
+                return {
+                    success: false,
+                    statusCode: provisionResult.status,
+                    error: String(provisionError.error || `Workspace provisioning failed (${provisionResult.status})`)
+                };
+            }
+            handshakeResult = await handshakeWorkspace(input.resolveCloudAuthUrl, input.workspaceId);
+            if (!handshakeResult.ok) {
+                const retryData = asObjectRecord(handshakeResult.data);
+                if (handshakeResult.status === 401) {
+                    return { success: false, statusCode: 401, error: String(retryData.error || 'Authentication required for workspace sync.') };
+                }
+                if (handshakeResult.status === 429) {
+                    return { success: false, statusCode: 429, retryAfterMs: handshakeResult.retryAfterMs, error: String(retryData.error || 'Workspace sync rate limited. Please retry later.') };
+                }
+                return {
+                    success: false,
+                    statusCode: handshakeResult.status,
+                    error: String(retryData.error || `Workspace sync handshake failed (${handshakeResult.status})`)
+                };
+            }
+            return { success: true, provisioned: true };
+        }
+        return {
+            success: false,
+            statusCode: handshakeResult.status,
+            error: String(data.error || `Workspace sync handshake failed (${handshakeResult.status})`)
+        };
+    }
+    catch {
+        return { success: false, error: 'Failed to validate workspace sync access.' };
+    }
+}
+async function computeIdempotencyKey(workspaceId, changes) {
+    const text = JSON.stringify([workspaceId, changes]);
+    try {
+        const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
+        return Array.from(new Uint8Array(buffer)).map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    catch {
+        // Deterministic fallback for environments lacking crypto.subtle.
+        // Uses FNV-1a over the serialized payload so retries with identical
+        // workspace+changes reuse the same idempotency key.
+        let hash = 0x811c9dc5;
+        for (let i = 0; i < text.length; i += 1) {
+            hash ^= text.charCodeAt(i);
+            hash = Math.imul(hash, 0x01000193);
+        }
+        const hex = (hash >>> 0).toString(16).padStart(8, '0');
+        return `${workspaceId}:fallback:${hex}`;
+    }
+}
+export async function runWorkspacePushSyncService(input) {
+    const changeCount = input.payload.changes.length;
+    const deleteCount = input.payload.deleteTaskIds.size;
+    const idempotencyKey = await computeIdempotencyKey(input.workspaceId, input.payload.changes);
+    let requestMs = 0;
+    // Attempt document encryption if key configured
+    let safeChanges = input.payload.changes;
+    if (typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
+        const syncKey = process.env.TASKFORCE_SYNC_KEY;
+        const encryptedChanges = [];
+        for (const change of safeChanges) {
+            if (change.op === 'document-upsert' && typeof change.content === 'string') {
+                encryptedChanges.push({
+                    ...change,
+                    content: await encryptDocument(change.content, syncKey)
+                });
+            }
+            else {
+                encryptedChanges.push(change);
+            }
+        }
+        safeChanges = encryptedChanges;
+    }
+    const sendPush = async () => {
+        const requestStartedAtMs = Date.now();
+        const result = await pushWorkspaceChanges(input.resolveCloudAuthUrl, {
+            workspaceId: input.workspaceId,
+            idempotencyKey,
+            changes: safeChanges
+        });
+        requestMs += (Date.now() - requestStartedAtMs);
+        return result;
+    };
+    let pushResult = await sendPush();
+    if (!pushResult.ok && (pushResult.status === 403 || pushResult.status === 409)) {
+        const ensured = await input.ensureCloudWorkspaceReadyForSync();
+        if (ensured.success) {
+            pushResult = await sendPush();
+        }
+    }
+    if (!pushResult.ok) {
+        const data = asObjectRecord(pushResult.data);
+        return {
+            success: false,
+            status: pushResult.status,
+            error: typeof data.error === 'string' ? data.error : undefined,
+            code: typeof data.code === 'string' ? data.code : undefined,
+            retryAfterMs: pushResult.retryAfterMs,
+            requestMs,
+            changeCount,
+            deleteCount,
+            currentTaskIds: input.payload.currentTaskIds,
+            deleteTaskIds: input.payload.deleteTaskIds,
+            currentDocumentPaths: input.payload.currentDocumentPaths,
+            deleteDocumentPaths: input.payload.deleteDocumentPaths,
+            currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
+            pushedWatermarks: new Map(),
+            emittedEventIds: []
+        };
+    }
+    const pushData = asObjectRecord(pushResult.data);
+    const emittedEventIds = Array.isArray(pushData.emittedEventIds)
+        ? Array.from(new Set(pushData.emittedEventIds
+            .map((entry) => String(entry || '').trim())
+            .filter(Boolean)))
+        : [];
+    return {
+        success: true,
+        syncedAt: new Date().toISOString(),
+        requestMs,
+        changeCount,
+        deleteCount,
+        currentTaskIds: input.payload.currentTaskIds,
+        deleteTaskIds: input.payload.deleteTaskIds,
+        currentDocumentPaths: input.payload.currentDocumentPaths,
+        deleteDocumentPaths: input.payload.deleteDocumentPaths,
+        currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
+        pushedWatermarks: input.payload.pushedWatermarks,
+        emittedEventIds
+    };
+}
+export async function runWorkspacePullSyncService(input) {
+    let cursor = input.cursor;
+    let hasMore = true;
+    let pages = 0;
+    let appliedChanges = 0;
+    let pullRequestMs = 0;
+    let applyMs = 0;
+    const pulledDeleteTaskIds = new Set();
+    let pulledActiveUpserts = false;
+    let pulledArchivedUpserts = false;
+    const documentDecryptFailures = new Set();
+    const maxPages = Number.isFinite(Number(input.maxPages)) ? Math.max(1, Math.floor(Number(input.maxPages))) : 20;
+    try {
+        while (hasMore && pages < maxPages) {
+            const requestPull = async () => {
+                const pullRequestStartedAtMs = Date.now();
+                const result = await pullWorkspaceChanges(input.resolveCloudAuthUrl, {
+                    workspaceId: input.workspaceId,
+                    cursor,
+                    limit: input.bootstrap ? 500 : 200
+                });
+                pullRequestMs += (Date.now() - pullRequestStartedAtMs);
+                return result;
+            };
+            let pullRes = await requestPull();
+            if (!pullRes.ok && pullRes.status === 403 && input.ensureCloudWorkspaceReadyForSync) {
+                const ensured = await input.ensureCloudWorkspaceReadyForSync();
+                if (ensured.success) {
+                    pullRes = await requestPull();
+                }
+            }
+            if (!pullRes.ok) {
+                return {
+                    success: false,
+                    kind: 'pull_http',
+                    status: pullRes.status,
+                    retryAfterMs: pullRes.retryAfterMs,
+                    cursor,
+                    pages,
+                    appliedChanges,
+                    pullRequestMs,
+                    applyMs,
+                    pulledDeleteTaskIds,
+                    pulledActiveUpserts,
+                    pulledArchivedUpserts,
+                    documentDecryptFailures: Array.from(documentDecryptFailures)
+                };
+            }
+            const pullData = pullRes.data || {};
+            const changes = Array.isArray(pullData?.changes) ? pullData.changes : [];
+            for (const change of changes) {
+                if (change.op === 'upsert') {
+                    const isArchivedUpsert = change?.archived === true || change?.task?.isArchived === true;
+                    if (isArchivedUpsert)
+                        pulledArchivedUpserts = true;
+                    else
+                        pulledActiveUpserts = true;
+                    continue;
+                }
+                if (change.op === 'document-upsert') {
+                    if (typeof change.content === 'string' && typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
+                        try {
+                            change.content = await decryptDocument(change.content, process.env.TASKFORCE_SYNC_KEY);
+                        }
+                        catch {
+                            // Leave encrypted content as fallback if decryption fails (e.g., bad key) so we don't drop the document entirely.
+                            const path = String(change.path || '').trim();
+                            if (path)
+                                documentDecryptFailures.add(path);
+                        }
+                    }
+                    continue;
+                }
+                if (change.op !== 'delete')
+                    continue;
+                const deleteTaskId = String(change.taskId || '').trim();
+                if (deleteTaskId)
+                    pulledDeleteTaskIds.add(deleteTaskId);
+            }
+            if (input.onPagePulled)
+                input.onPagePulled();
+            if (changes.length > 0) {
+                const applyStartedAtMs = Date.now();
+                const applyResult = await applyLocalWorkspaceChanges(input.workspaceId, changes);
+                const applyFailures = applyResult.failures;
+                if (!applyResult.ok) {
+                    applyMs += (Date.now() - applyStartedAtMs);
+                    const hasAuthFailure = applyFailures.some((entry) => entry.endsWith(':401'));
+                    if (hasAuthFailure) {
+                        return {
+                            success: false,
+                            kind: 'apply_auth',
+                            status: 401,
+                            failures: applyFailures,
+                            cursor,
+                            pages,
+                            appliedChanges,
+                            pullRequestMs,
+                            applyMs,
+                            pulledDeleteTaskIds,
+                            pulledActiveUpserts,
+                            pulledArchivedUpserts,
+                            documentDecryptFailures: Array.from(documentDecryptFailures)
+                        };
+                    }
+                    const hasTransientApplyFailure = applyFailures.some((entry) => {
+                        if (entry.endsWith(':network'))
+                            return true;
+                        const statusText = entry.split(':').pop() || '';
+                        const status = Number.parseInt(statusText, 10);
+                        return Number.isFinite(status) && (status === 429 || status >= 500);
+                    });
+                    return {
+                        success: false,
+                        kind: 'apply_all_candidates',
+                        failures: applyFailures,
+                        hasTransientApplyFailure,
+                        cursor,
+                        pages,
+                        appliedChanges,
+                        pullRequestMs,
+                        applyMs,
+                        pulledDeleteTaskIds,
+                        pulledActiveUpserts,
+                        pulledArchivedUpserts,
+                        documentDecryptFailures: Array.from(documentDecryptFailures)
+                    };
+                }
+                const applyPayloadData = asObjectRecord(applyResult.data);
+                if (applyPayloadData.success === false) {
+                    applyMs += (Date.now() - applyStartedAtMs);
+                    return {
+                        success: false,
+                        kind: 'apply_payload',
+                        error: String(applyPayloadData.error || 'Workspace sync apply failed.'),
+                        cursor,
+                        pages,
+                        appliedChanges,
+                        pullRequestMs,
+                        applyMs,
+                        pulledDeleteTaskIds,
+                        pulledActiveUpserts,
+                        pulledArchivedUpserts,
+                        documentDecryptFailures: Array.from(documentDecryptFailures)
+                    };
+                }
+                applyMs += (Date.now() - applyStartedAtMs);
+                appliedChanges += changes.length;
+                if (input.onChangesApplied)
+                    input.onChangesApplied(changes.length);
+            }
+            if (pullData && 'nextCursor' in pullData) {
+                if (pullData.nextCursor === null || typeof pullData.nextCursor === 'string') {
+                    cursor = pullData.nextCursor;
+                }
+            }
+            hasMore = Boolean(pullData?.hasMore);
+            pages += 1;
+        }
+        return {
+            success: true,
+            syncedAt: new Date().toISOString(),
+            cursor: cursor || null,
+            pages,
+            appliedChanges,
+            pullRequestMs,
+            applyMs,
+            pulledDeleteTaskIds,
+            pulledActiveUpserts,
+            pulledArchivedUpserts,
+            documentDecryptFailures: Array.from(documentDecryptFailures)
+        };
+    }
+    catch {
+        return {
+            success: false,
+            kind: 'exception',
+            cursor: cursor || null,
+            pages,
+            appliedChanges,
+            pullRequestMs,
+            applyMs,
+            pulledDeleteTaskIds,
+            pulledActiveUpserts,
+            pulledArchivedUpserts,
+            documentDecryptFailures: Array.from(documentDecryptFailures)
+        };
+    }
+}
+export async function syncUserGlobalSettingsService(input) {
+    const isTransientStatus = (status) => status === 0 || status === 429 || status >= 500;
+    const pullResult = await pullUserSettings(input.resolveCloudAuthUrl);
+    if (!pullResult.ok) {
+        const status = Number(pullResult.status || 0);
+        return {
+            success: false,
+            error: `Sync pull failed (${pullResult.status})`,
+            statusCode: pullResult.status,
+            retryAfterMs: pullResult.retryAfterMs,
+            transient: isTransientStatus(status)
+        };
+    }
+    const pullData = asObjectRecord(pullResult.data);
+    const remoteSettings = pullData.settings && typeof pullData.settings === 'object'
+        ? pullData.settings
+        : {};
+    const remoteUpdatedAt = typeof pullData.updatedAt === 'string' && pullData.updatedAt.trim().length > 0
+        ? pullData.updatedAt.trim()
+        : null;
+    const localUpdatedAt = input.getLocalUpdatedAt(input.userId);
+    const localMs = localUpdatedAt ? Date.parse(localUpdatedAt) : NaN;
+    const remoteMs = remoteUpdatedAt ? Date.parse(remoteUpdatedAt) : NaN;
+    if (!localUpdatedAt && input.preferCloudOnFirstSync && Number.isFinite(remoteMs)) {
+        await input.applyRemoteSettings(remoteSettings);
+        return { success: true, mode: 'pulled', updatedAt: remoteUpdatedAt };
+    }
+    if (Number.isFinite(remoteMs) && (!Number.isFinite(localMs) || remoteMs > localMs)) {
+        await input.applyRemoteSettings(remoteSettings);
+        return { success: true, mode: 'pulled', updatedAt: remoteUpdatedAt };
+    }
+    const nextLocalUpdatedAt = localUpdatedAt || new Date().toISOString();
+    const pushResult = await pushUserSettings(input.resolveCloudAuthUrl, {
+        settings: input.buildLocalSettings(),
+        updatedAt: nextLocalUpdatedAt
+    });
+    if (!pushResult.ok) {
+        const status = Number(pushResult.status || 0);
+        return {
+            success: false,
+            error: `Sync push failed (${pushResult.status})`,
+            statusCode: pushResult.status,
+            retryAfterMs: pushResult.retryAfterMs,
+            transient: isTransientStatus(status)
+        };
+    }
+    const pushData = asObjectRecord(pushResult.data);
+    const acceptedUpdatedAt = typeof pushData.updatedAt === 'string' && pushData.updatedAt.trim().length > 0
+        ? pushData.updatedAt.trim()
+        : nextLocalUpdatedAt;
+    return {
+        success: true,
+        mode: 'pushed',
+        updatedAt: acceptedUpdatedAt
+    };
+}
+export function calculateWorkspaceRetryDelayMs(attempt) {
+    const safeAttempt = Math.max(1, Math.floor(Number(attempt) || 1));
+    const cappedBaseMs = Math.min(120_000, 1500 * (2 ** Math.max(0, safeAttempt - 1)));
+    const jitterMs = Math.floor(cappedBaseMs * (0.15 * Math.random()));
+    return cappedBaseMs + jitterMs;
+}

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

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