@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/server/routes/syncV3LocalFeedApplyRoutes.js

@@ -0,0 +1,493 @@
+import { applyWorkspaceSyncV3InitiativeDeltaPage, applyWorkspaceSyncV3InitiativeFallbackRepairPage, applyWorkspaceSyncV3InitiativeRepairPage, rollbackWorkspaceSyncV3InitiativeProjection } from '../../sync/v3/workspaceSyncV3InitiativeLocalApply.js';
+import { WorkspaceSyncV3ProjectionStateStore } from '../../sync/v3/workspaceSyncV3ProjectionState.js';
+import { applyWorkspaceSyncV3CombinedLocalFeed, readWorkspaceSyncV3CombinedLocalProjection, } from '../../sync/engine/workspaceSyncEngineV3LocalFeedApply.js';
+import { WORKSPACE_SYNC_V3_COVERAGE_PROFILE } from '../../sync/v3/workspaceSyncV3FeedProfile.js';
+import { resolveWorkspaceSyncV3RegisteredCoverage } from '../../sync/v3/workspaceSyncV3CoverageRegistry.js';
+import { resolveWorkspaceSyncV3CombinedWireContract } from '../../sync/v3/workspaceSyncV3CombinedWireContract.js';
+import { resolveCombinedFeedCapability, resolveRequestedCombinedFeedCoverage } from '../../sync/v3/combinedFeedCapability.js';
+import { parseJsonBody } from './primitives.js';
+import { applyWorkspaceSyncV3TaskCommentAuditPage, readWorkspaceSyncV3TaskCommentAuditCursor, readWorkspaceSyncV3TaskCommentAuditState, } from '../../sync/v3/workspaceSyncV3TaskCommentAudit.js';
+import { createLocalSyncBrowserApplyPermitTransactionHooks, parseLocalSyncBrowserApplyPermitContext, } from '../../sync/coordinator/localSyncBrowserApplyPermitContext.js';
+const ROUTE_PATH = '/api/taskforce/sync/v3/local/feed';
+const TASK_COMMENT_AUDIT_PATH = '/api/taskforce/sync/v3/local/task-comment-audit';
+const MAX_BODY_BYTES = 8 * 1024 * 1024;
+function writeJson(res, statusCode, body) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(body));
+}
+function workspaceFromUrl(req) {
+    try {
+        return String(new URL(req.url || ROUTE_PATH, 'http://localhost').searchParams.get('workspaceId') || '').trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function isWorkspaceSyncV3LocalFeedApplyEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_LOCAL_FEED_APPLY_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3CombinedLocalFeedApplyEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_COMBINED_LOCAL_FEED_APPLY_ENABLED || '').trim())
+        && isWorkspaceSyncV3LocalFeedApplyEnabled(env);
+}
+function selectCoverage(profileId, version, digest) {
+    const selectedId = String(profileId || '').trim();
+    const selectedVersion = String(version || '').trim();
+    const selectedDigest = String(digest || '').trim();
+    if (!selectedId && !selectedVersion && !selectedDigest)
+        return { kind: 'initiative' };
+    if (selectedId === WORKSPACE_SYNC_V3_COVERAGE_PROFILE.coverageProfileId
+        && selectedVersion === String(WORKSPACE_SYNC_V3_COVERAGE_PROFILE.coverageVersion)
+        && selectedDigest === WORKSPACE_SYNC_V3_COVERAGE_PROFILE.coverageDigest)
+        return { kind: 'initiative' };
+    const registered = resolveWorkspaceSyncV3RegisteredCoverage({
+        coverageProfileId: selectedId, coverageVersion: selectedVersion, coverageDigest: selectedDigest,
+    });
+    const wire = resolveWorkspaceSyncV3CombinedWireContract({
+        coverageProfileId: selectedId, coverageVersion: selectedVersion, coverageDigest: selectedDigest,
+    });
+    if (registered && wire)
+        return { kind: 'combined', registered, wire };
+    return null;
+}
+function pageMatchesCoverage(page, coverage) {
+    if (!page || typeof page !== 'object' || Array.isArray(page))
+        return false;
+    const selected = page.coverage;
+    return Boolean(selected
+        && selected.coverageProfileId === coverage.profile.coverageProfileId
+        && Number(selected.coverageVersion) === coverage.profile.coverageVersion
+        && selected.coverageDigest === coverage.profile.coverageDigest);
+}
+function initiativeCommittedBoundary(projection) {
+    return {
+        version: 1,
+        projection: 'initiative',
+        cursor: projection.repair?.cursor ?? projection.opaqueCursor,
+    };
+}
+function combinedCommittedBoundary(projection, coverage = projection) {
+    return {
+        version: 1,
+        projection: 'combined',
+        cursor: projection.repair?.cursor ?? projection.opaqueCursor,
+        coverage: {
+            coverageProfileId: coverage.coverageProfileId,
+            coverageVersion: coverage.coverageVersion,
+            coverageDigest: coverage.coverageDigest,
+        },
+    };
+}
+function auditCommittedBoundary(cursor) {
+    return {
+        version: 1,
+        projection: 'task-comment-audit',
+        cursor,
+    };
+}
+function nextApplyCursor(kind, page) {
+    if (kind === 'delta')
+        return String(page.nextCursor || '') || null;
+    if (page.hasMore === true)
+        return String(page.nextRepairCursor || '') || null;
+    return kind === 'repair' ? String(page.resumeCursor || '') || null : null;
+}
+function requireBrowserPermitServices(services) {
+    if (services)
+        return services;
+    throw new Error('The local sync browser apply coordinator service is unavailable.');
+}
+function resolveFeedPermitTransactionHooks(input) {
+    if (!input.context)
+        return undefined;
+    const expectedOperationClasses = input.kind === 'delta'
+        || (input.kind === 'repair'
+            && input.projection === 'initiative'
+            && input.previousCursor === null)
+        ? ['pull']
+        : input.kind === 'repair' && input.previousCursor === null
+            ? ['pull', 'repair']
+            : ['repair'];
+    const expectedBoundary = {
+        ...input.currentBoundary,
+        cursor: nextApplyCursor(input.kind, input.page),
+    };
+    const requestedBoundary = {
+        ...input.currentBoundary,
+        cursor: input.previousCursor,
+    };
+    return createLocalSyncBrowserApplyPermitTransactionHooks({
+        services: requireBrowserPermitServices(input.services),
+        cookieHeader: input.req.headers.cookie,
+        workspaceId: input.workspaceId,
+        context: input.context,
+        expectedOperationClasses,
+        previousBoundary: requestedBoundary,
+        expectedBoundary,
+        commitBoundary: ({ applyResult }) => {
+            const projection = applyResult?.projection;
+            if (!projection || typeof projection !== 'object') {
+                throw new Error('The local feed apply did not return a committed projection boundary.');
+            }
+            return input.projection === 'combined'
+                ? combinedCommittedBoundary(projection, input.currentBoundary.coverage)
+                : initiativeCommittedBoundary(projection);
+        },
+    });
+}
+export function registerWorkspaceSyncV3LocalFeedApplyRoutes(input) {
+    const enabled = input.enabled ?? isWorkspaceSyncV3LocalFeedApplyEnabled();
+    const combinedEnabled = input.combinedEnabled
+        ?? isWorkspaceSyncV3CombinedLocalFeedApplyEnabled(input.env || process.env);
+    const routeEnv = input.env || process.env;
+    const configuredCombinedCoverage = /^(1|true|on|yes)$/i.test(String(routeEnv.TASKFORCE_SYNC_V3_COMBINED_FEED_ACTIVATION_ENABLED || '').trim())
+        ? resolveRequestedCombinedFeedCoverage(routeEnv)
+        : null;
+    const now = input.now || (() => new Date());
+    const resolveActiveWorkspaceId = input.resolveActiveWorkspaceId
+        || (() => input.core.resolvePreferredWorkspaceId({ allowDefault: true }));
+    input.addRoute('GET', TASK_COMMENT_AUDIT_PATH, async (req, res) => {
+        if (input.context.authConfig?.runtimeMode === 'cloud' || !combinedEnabled) {
+            writeJson(res, 404, { success: false, code: 'WORKSPACE_SYNC_V3_TASK_COMMENT_AUDIT_DISABLED', error: 'Not found.' });
+            return;
+        }
+        const workspaceId = workspaceFromUrl(req);
+        const activeWorkspaceId = String(resolveActiveWorkspaceId() || '').trim();
+        if (!workspaceId || workspaceId !== activeWorkspaceId) {
+            writeJson(res, 409, {
+                success: false,
+                code: 'WORKSPACE_SYNC_LOCAL_WORKSPACE_MISMATCH',
+                error: 'Request workspace does not match the active local workspace.',
+            });
+            return;
+        }
+        const state = readWorkspaceSyncV3TaskCommentAuditState({ core: input.core, workspaceId });
+        writeJson(res, 200, {
+            success: true,
+            contractVersion: 3,
+            workspaceId,
+            cursor: state.cursor,
+            nextSweepAt: state.nextSweepAt,
+        });
+    });
+    input.addRoute('POST', TASK_COMMENT_AUDIT_PATH, async (req, res) => {
+        if (input.context.authConfig?.runtimeMode === 'cloud' || !combinedEnabled) {
+            writeJson(res, 404, { success: false, code: 'WORKSPACE_SYNC_V3_TASK_COMMENT_AUDIT_DISABLED', error: 'Not found.' });
+            return;
+        }
+        try {
+            const body = await parseJsonBody(req, MAX_BODY_BYTES);
+            const workspaceId = String(body.workspaceId || '').trim();
+            const activeWorkspaceId = String(resolveActiveWorkspaceId() || '').trim();
+            if (!workspaceId || workspaceId !== activeWorkspaceId) {
+                writeJson(res, 409, {
+                    success: false,
+                    code: 'WORKSPACE_SYNC_LOCAL_WORKSPACE_MISMATCH',
+                    error: 'Request workspace does not match the active local workspace.',
+                });
+                return;
+            }
+            const permitContext = parseLocalSyncBrowserApplyPermitContext(body);
+            const currentCursor = readWorkspaceSyncV3TaskCommentAuditCursor({
+                core: input.core,
+                workspaceId,
+            });
+            const transactionHooks = permitContext
+                ? createLocalSyncBrowserApplyPermitTransactionHooks({
+                    services: requireBrowserPermitServices(input.context.localSyncCoordinator),
+                    cookieHeader: req.headers.cookie,
+                    workspaceId,
+                    context: permitContext,
+                    expectedOperationClasses: ['pull'],
+                    previousBoundary: auditCommittedBoundary(currentCursor),
+                    expectedBoundary: auditCommittedBoundary(String(body.page?.nextCursor || '') || null),
+                    commitBoundary: ({ applyResult }) => {
+                        const nextCursor = applyResult?.nextCursor;
+                        return auditCommittedBoundary(nextCursor == null ? null : String(nextCursor));
+                    },
+                })
+                : undefined;
+            const result = applyWorkspaceSyncV3TaskCommentAuditPage({
+                core: input.core,
+                workspaceId,
+                page: body.page,
+                now: now().toISOString(),
+                ...(transactionHooks ? { transactionHooks } : {}),
+            });
+            writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, result });
+        }
+        catch (error) {
+            writeJson(res, 409, {
+                success: false,
+                code: 'WORKSPACE_SYNC_V3_TASK_COMMENT_AUDIT_APPLY_REJECTED',
+                error: String(error?.message || error),
+            });
+        }
+    });
+    input.addRoute('GET', ROUTE_PATH, async (req, res) => {
+        if (input.context.authConfig?.runtimeMode === 'cloud') {
+            writeJson(res, 404, { success: false, code: 'WORKSPACE_SYNC_V3_LOCAL_FEED_DISABLED', error: 'Not found.' });
+            return;
+        }
+        const workspaceId = workspaceFromUrl(req);
+        const url = new URL(req.url || ROUTE_PATH, 'http://localhost');
+        const selectorKeys = ['coverageProfileId', 'coverageVersion', 'coverageDigest'];
+        if (selectorKeys.some((key) => url.searchParams.has(key))
+            && selectorKeys.some((key) => url.searchParams.getAll(key).length !== 1)) {
+            writeJson(res, 400, { success: false, code: 'UNSUPPORTED_SYNC_V3_COVERAGE', error: 'Unsupported feed coverage profile.' });
+            return;
+        }
+        const coverage = selectCoverage(url.searchParams.get('coverageProfileId'), url.searchParams.get('coverageVersion'), url.searchParams.get('coverageDigest'));
+        if (!coverage) {
+            writeJson(res, 400, { success: false, code: 'UNSUPPORTED_SYNC_V3_COVERAGE', error: 'Unsupported feed coverage profile.' });
+            return;
+        }
+        const activeWorkspaceId = String(resolveActiveWorkspaceId() || '').trim();
+        if (!workspaceId || workspaceId !== activeWorkspaceId) {
+            writeJson(res, 409, { success: false, code: 'WORKSPACE_SYNC_LOCAL_WORKSPACE_MISMATCH',
+                error: 'Request workspace does not match the active local workspace.' });
+            return;
+        }
+        const projection = coverage.kind === 'combined'
+            ? readWorkspaceSyncV3CombinedLocalProjection({ core: input.core, workspaceId })
+            : new WorkspaceSyncV3ProjectionStateStore(input.core.getDatabaseAdapter())
+                .read({ tenantId: input.core.getTenantId(), workspaceId });
+        writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, projection });
+    });
+    input.addRoute('POST', ROUTE_PATH, async (req, res) => {
+        if (input.context.authConfig?.runtimeMode === 'cloud') {
+            writeJson(res, 404, { success: false, code: 'WORKSPACE_SYNC_V3_LOCAL_FEED_DISABLED', error: 'Not found.' });
+            return;
+        }
+        try {
+            const body = await parseJsonBody(req, MAX_BODY_BYTES);
+            const workspaceId = String(body?.workspaceId || '').trim();
+            const coverage = selectCoverage(body.coverageProfileId, body.coverageVersion, body.coverageDigest);
+            if (!coverage) {
+                writeJson(res, 400, { success: false, code: 'UNSUPPORTED_SYNC_V3_COVERAGE', error: 'Unsupported feed coverage profile.' });
+                return;
+            }
+            const activeWorkspaceId = String(resolveActiveWorkspaceId() || '').trim();
+            if (!workspaceId || workspaceId !== activeWorkspaceId) {
+                writeJson(res, 409, { success: false, code: 'WORKSPACE_SYNC_LOCAL_WORKSPACE_MISMATCH',
+                    error: 'Request workspace does not match the active local workspace.' });
+                return;
+            }
+            const kind = String(body.kind || '').trim();
+            const permitContext = parseLocalSyncBrowserApplyPermitContext(body);
+            if (coverage.kind === 'combined') {
+                if (kind !== 'delta' && kind !== 'repair' && kind !== 'fallback-repair') {
+                    writeJson(res, 400, { success: false, code: 'WORKSPACE_SYNC_V3_LOCAL_FEED_REQUEST_INVALID',
+                        error: 'Combined feed apply kind must be repair, delta, or fallback-repair.' });
+                    return;
+                }
+                const current = readWorkspaceSyncV3CombinedLocalProjection({
+                    core: input.core,
+                    workspaceId,
+                });
+                const transactionHooks = resolveFeedPermitTransactionHooks({
+                    req,
+                    workspaceId,
+                    kind,
+                    previousCursor: body.previousCursor == null
+                        ? null
+                        : String(body.previousCursor),
+                    page: body.page,
+                    projection: 'combined',
+                    currentBoundary: combinedCommittedBoundary(current, coverage.registered.profile),
+                    context: permitContext,
+                    services: input.context.localSyncCoordinator,
+                });
+                if (configuredCombinedCoverage
+                    && (coverage.registered.profile.coverageProfileId !== configuredCombinedCoverage.coverageProfileId
+                        || coverage.registered.profile.coverageVersion !== configuredCombinedCoverage.coverageVersion
+                        || coverage.registered.profile.coverageDigest !== configuredCombinedCoverage.coverageDigest)) {
+                    writeJson(res, 409, {
+                        success: false,
+                        code: 'WORKSPACE_SYNC_V3_LOCAL_FEED_CONFIG_SELECTOR_MISMATCH',
+                        error: 'Combined feed apply coverage does not match the local runtime configuration.',
+                        configuredCoverage: configuredCombinedCoverage,
+                    });
+                    return;
+                }
+                if (!pageMatchesCoverage(body.page, coverage.registered)) {
+                    writeJson(res, 409, { success: false, code: 'WORKSPACE_SYNC_V3_LOCAL_FEED_SELECTOR_MISMATCH',
+                        error: 'Combined feed page coverage does not match the requested selector.' });
+                    return;
+                }
+                if (kind === 'fallback-repair') {
+                    const result = applyWorkspaceSyncV3CombinedLocalFeed({
+                        core: input.core,
+                        workspaceId,
+                        now: now().toISOString(),
+                        command: {
+                            kind: 'fallback-repair',
+                            expectedEpoch: String(body.epoch || ''),
+                            previousRepairCursor: body.previousCursor == null ? null : String(body.previousCursor),
+                            page: body.page,
+                        },
+                        ...(transactionHooks ? { transactionHooks } : {}),
+                    });
+                    writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, result });
+                    return;
+                }
+                if (!combinedEnabled) {
+                    writeJson(res, 404, { success: false, code: 'WORKSPACE_SYNC_V3_COMBINED_LOCAL_FEED_DISABLED', error: 'Not found.' });
+                    return;
+                }
+                if (coverage.wire.nestedWriterPrerequisitesRequired) {
+                    const capability = resolveCombinedFeedCapability({
+                        runtimeMode: 'local', env: routeEnv, coverage: coverage.wire.coverage,
+                    }).combinedFeed;
+                    if (!capability.activationReady) {
+                        writeJson(res, 409, { success: false, code: 'WORKSPACE_SYNC_V3_COMBINED_LOCAL_FEED_NOT_READY',
+                            error: 'Combined feed local activation prerequisites are incomplete.',
+                            missingPrerequisites: capability.missingPrerequisites });
+                        return;
+                    }
+                }
+                if (kind === 'repair') {
+                    const recoveryBatchId = body.recoveryBatchId == null
+                        ? ''
+                        : String(body.recoveryBatchId).trim();
+                    if (recoveryBatchId && !/^recovery-[A-Za-z0-9-]{1,200}$/.test(recoveryBatchId)) {
+                        writeJson(res, 400, {
+                            success: false,
+                            code: 'WORKSPACE_SYNC_LOCAL_RECOVERY_ID_INVALID',
+                            error: 'Workspace sync recovery batch id is invalid.',
+                        });
+                        return;
+                    }
+                    const result = applyWorkspaceSyncV3CombinedLocalFeed({
+                        core: input.core,
+                        workspaceId,
+                        now: now().toISOString(),
+                        command: {
+                            kind: 'repair',
+                            expectedEpoch: String(body.epoch || ''),
+                            previousRepairCursor: body.previousCursor == null ? null : String(body.previousCursor),
+                            page: body.page,
+                            ...(recoveryBatchId ? { recoveryBatchId } : {}),
+                        },
+                        ...(transactionHooks ? { transactionHooks } : {}),
+                    });
+                    writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, result });
+                    return;
+                }
+                if (kind === 'delta') {
+                    const result = applyWorkspaceSyncV3CombinedLocalFeed({
+                        core: input.core,
+                        workspaceId,
+                        now: now().toISOString(),
+                        command: {
+                            kind: 'delta',
+                            epoch: String(body.epoch || ''),
+                            previousCursor: String(body.previousCursor || ''),
+                            page: body.page,
+                        },
+                        ...(transactionHooks ? { transactionHooks } : {}),
+                    });
+                    writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, result });
+                    return;
+                }
+            }
+            if (kind === 'rollback') {
+                if (permitContext) {
+                    throw new Error('Rollback does not accept a local sync browser apply permit context.');
+                }
+                const projection = rollbackWorkspaceSyncV3InitiativeProjection({
+                    core: input.core,
+                    workspaceId,
+                    expectedEpoch: String(body.epoch || ''),
+                    now: now().toISOString(),
+                });
+                writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, projection });
+                return;
+            }
+            const current = new WorkspaceSyncV3ProjectionStateStore(input.core.getDatabaseAdapter()).read({
+                tenantId: input.core.getTenantId(),
+                workspaceId,
+            });
+            if (kind === 'fallback-repair') {
+                const transactionHooks = resolveFeedPermitTransactionHooks({
+                    req,
+                    workspaceId,
+                    context: permitContext,
+                    kind,
+                    previousCursor: body.previousCursor == null
+                        ? null
+                        : String(body.previousCursor),
+                    page: body.page,
+                    projection: 'initiative',
+                    currentBoundary: initiativeCommittedBoundary(current),
+                    services: input.context.localSyncCoordinator,
+                });
+                const result = applyWorkspaceSyncV3InitiativeFallbackRepairPage({ core: input.core, workspaceId,
+                    expectedEpoch: String(body.epoch || ''),
+                    previousRepairCursor: body.previousCursor == null ? null : String(body.previousCursor),
+                    page: body.page, now: now().toISOString(),
+                    ...(transactionHooks ? { transactionHooks } : {}) });
+                writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, result });
+                return;
+            }
+            if (!enabled) {
+                writeJson(res, 404, { success: false, code: 'WORKSPACE_SYNC_V3_LOCAL_FEED_DISABLED', error: 'Not found.' });
+                return;
+            }
+            if (kind === 'repair') {
+                const transactionHooks = resolveFeedPermitTransactionHooks({
+                    req,
+                    workspaceId,
+                    context: permitContext,
+                    kind,
+                    previousCursor: body.previousCursor == null
+                        ? null
+                        : String(body.previousCursor),
+                    page: body.page,
+                    projection: 'initiative',
+                    currentBoundary: initiativeCommittedBoundary(current),
+                    services: input.context.localSyncCoordinator,
+                });
+                const result = applyWorkspaceSyncV3InitiativeRepairPage({ core: input.core, workspaceId,
+                    expectedEpoch: String(body.epoch || ''),
+                    previousRepairCursor: body.previousCursor == null ? null : String(body.previousCursor),
+                    page: body.page, now: now().toISOString(),
+                    ...(transactionHooks ? { transactionHooks } : {}) });
+                writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, result });
+                return;
+            }
+            if (kind === 'delta') {
+                const transactionHooks = resolveFeedPermitTransactionHooks({
+                    req,
+                    workspaceId,
+                    context: permitContext,
+                    kind,
+                    previousCursor: String(body.previousCursor || ''),
+                    page: body.page,
+                    projection: 'initiative',
+                    currentBoundary: initiativeCommittedBoundary(current),
+                    services: input.context.localSyncCoordinator,
+                });
+                const result = applyWorkspaceSyncV3InitiativeDeltaPage({ core: input.core, workspaceId,
+                    epoch: String(body.epoch || ''), previousCursor: String(body.previousCursor || ''),
+                    page: body.page, now: now().toISOString(),
+                    ...(transactionHooks ? { transactionHooks } : {}) });
+                writeJson(res, 200, { success: true, contractVersion: 3, workspaceId, result });
+                return;
+            }
+            writeJson(res, 400, { success: false, code: 'WORKSPACE_SYNC_V3_LOCAL_FEED_REQUEST_INVALID',
+                error: 'Feed apply kind must be repair, delta, fallback-repair, or rollback.' });
+        }
+        catch (error) {
+            const causeCode = String(error?.code || '').trim();
+            const causeAssetId = String(error?.assetId || '').trim();
+            writeJson(res, 409, {
+                success: false,
+                code: 'WORKSPACE_SYNC_V3_LOCAL_FEED_APPLY_REJECTED',
+                error: String(error?.message || error),
+                ...(causeCode ? { causeCode } : {}),
+                ...(causeAssetId ? { causeAssetId } : {}),
+            });
+        }
+    });
+}

package/dist/server/routes/syncV3LocalOwnershipRoutes.d.ts

@@ -0,0 +1,10 @@
+import type { SyncAddRoute, SyncRouteAuthConfig, SyncRouteCore } from './syncRouteTypes.js';
+export declare function registerWorkspaceSyncV3LocalOwnershipRoutes(input: {
+    addRoute: SyncAddRoute;
+    core: SyncRouteCore;
+    context: {
+        authConfig?: SyncRouteAuthConfig | null;
+    };
+    enabled?: boolean;
+    resolveActiveWorkspaceId?: () => string | null;
+}): void;

package/dist/server/routes/syncV3LocalOwnershipRoutes.js

@@ -0,0 +1,51 @@
+import { readWorkspaceSyncLocalOwnershipSnapshot } from '../../sync/v3/workspaceSyncLocalOwnershipSnapshot.js';
+const ROUTE_PATH = '/api/taskforce/sync/v3/local/metadata-ownership';
+function writeJson(res, statusCode, body) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(body));
+}
+function requestedWorkspaceId(req) {
+    try {
+        return String(new URL(req.url || ROUTE_PATH, 'http://localhost').searchParams.get('workspaceId') || '').trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function registerWorkspaceSyncV3LocalOwnershipRoutes(input) {
+    // This read-only projection is a coexistence safety boundary, not an
+    // activation surface. It must remain available after capture is disabled
+    // so already-persisted durable operations cannot leak into legacy pushes.
+    const enabled = input.enabled ?? true;
+    const resolveActiveWorkspaceId = input.resolveActiveWorkspaceId
+        || (() => input.core.resolvePreferredWorkspaceId({ allowDefault: true }));
+    input.addRoute('GET', ROUTE_PATH, async (req, res) => {
+        if (!enabled || input.context.authConfig?.runtimeMode === 'cloud') {
+            writeJson(res, 404, { success: false, error: 'Not found.', code: 'WORKSPACE_SYNC_LOCAL_OWNERSHIP_DISABLED' });
+            return;
+        }
+        const workspaceId = requestedWorkspaceId(req);
+        const activeWorkspaceId = String(resolveActiveWorkspaceId() || '').trim();
+        if (!workspaceId || !activeWorkspaceId || workspaceId !== activeWorkspaceId) {
+            writeJson(res, 409, {
+                success: false,
+                error: 'Request workspace does not match the active local workspace.',
+                code: 'WORKSPACE_SYNC_LOCAL_WORKSPACE_MISMATCH',
+            });
+            return;
+        }
+        try {
+            writeJson(res, 200, readWorkspaceSyncLocalOwnershipSnapshot({
+                core: input.core,
+                workspaceId,
+            }));
+        }
+        catch {
+            writeJson(res, 500, {
+                success: false,
+                error: 'Failed to read local workspace sync metadata ownership.',
+                code: 'WORKSPACE_SYNC_LOCAL_OWNERSHIP_INTERNAL_ERROR',
+            });
+        }
+    });
+}

package/dist/server/routes/syncV3LocalRecoveryRoutes.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage } from 'http';
+import type { SyncAddRoute, SyncRouteAuthConfig, SyncRouteCore } from './syncRouteTypes.js';
+export declare function registerWorkspaceSyncV3LocalRecoveryRoutes(input: {
+    addRoute: SyncAddRoute;
+    core: SyncRouteCore;
+    context: {
+        authConfig?: SyncRouteAuthConfig | null;
+    };
+    requestWorkspaceId: (req: IncomingMessage) => string | null;
+    now?: () => Date;
+    createRecoveryBatchId?: () => string;
+}): void;

package/dist/server/routes/syncV3LocalRecoveryRoutes.js

@@ -0,0 +1,78 @@
+import { randomUUID } from 'crypto';
+import { prepareLocalOutboxRecovery } from '../../sync/v3/localOutboxRecoveryPreparationService.js';
+import { WorkspaceSyncDurabilityStore } from '../../sync/v3/syncDurabilityStore.js';
+import { parseJsonBody } from './primitives.js';
+const ROUTE_PATH = '/api/taskforce/sync/v3/local/recovery';
+class LocalRecoveryRequestError extends Error {
+    code;
+    statusCode;
+    constructor(message, code = 'WORKSPACE_SYNC_LOCAL_RECOVERY_INVALID', statusCode = 400) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'LocalRecoveryRequestError';
+    }
+}
+function writeJson(res, statusCode, body) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(body));
+}
+function parseRequest(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new LocalRecoveryRequestError('Request must be an object.');
+    }
+    const body = raw;
+    if (Object.keys(body).sort().join(',') !== 'workspaceId') {
+        throw new LocalRecoveryRequestError('Request must contain workspaceId only.');
+    }
+    const workspaceId = typeof body.workspaceId === 'string' ? body.workspaceId.trim() : '';
+    if (!workspaceId || workspaceId.length > 200) {
+        throw new LocalRecoveryRequestError('workspaceId is invalid.');
+    }
+    return { workspaceId };
+}
+export function registerWorkspaceSyncV3LocalRecoveryRoutes(input) {
+    const now = input.now || (() => new Date());
+    const createRecoveryBatchId = input.createRecoveryBatchId || (() => `recovery-${randomUUID()}`);
+    input.addRoute('POST', ROUTE_PATH, async (req, res) => {
+        if (input.context.authConfig?.runtimeMode === 'cloud') {
+            writeJson(res, 404, {
+                success: false,
+                error: 'Not found.',
+                code: 'WORKSPACE_SYNC_LOCAL_RECOVERY_CLOUD_RUNTIME',
+            });
+            return;
+        }
+        try {
+            const body = parseRequest(await parseJsonBody(req));
+            const activeWorkspaceId = input.requestWorkspaceId(req);
+            if (!activeWorkspaceId || activeWorkspaceId !== body.workspaceId) {
+                throw new LocalRecoveryRequestError('Request workspace does not match the active local workspace.', 'WORKSPACE_SYNC_LOCAL_WORKSPACE_MISMATCH', 409);
+            }
+            const tenantId = input.core.getTenantId();
+            const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+            const timestamp = now().toISOString();
+            const prepared = prepareLocalOutboxRecovery({
+                store,
+                tenantId,
+                workspaceId: body.workspaceId,
+                now: timestamp,
+                createRecoveryBatchId,
+            });
+            writeJson(res, 200, {
+                success: true,
+                kind: prepared.kind,
+                needsAuthoritativeRepair: prepared.needsAuthoritativeRepair,
+                recovery: prepared.recovery,
+            });
+        }
+        catch (error) {
+            const known = error instanceof LocalRecoveryRequestError;
+            writeJson(res, known ? error.statusCode : 409, {
+                success: false,
+                error: known ? error.message : String(error?.message || 'Workspace sync recovery could not start.'),
+                code: known ? error.code : 'WORKSPACE_SYNC_LOCAL_RECOVERY_BLOCKED',
+            });
+        }
+    });
+}