@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/sync/workspaceRepair.js

@@ -0,0 +1,566 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash, randomUUID } from 'crypto';
+import { compareWorkspaceMutationOrdering } from './workspaceSyncSurface.js';
+function normalizeWorkspaceId(raw) {
+    return String(raw || '').trim() || 'default';
+}
+function toRelativeWorkspacePath(basePath, candidatePath) {
+    const root = path.resolve(basePath);
+    const absolute = path.resolve(candidatePath);
+    if (absolute !== root && !absolute.startsWith(`${root}${path.sep}`))
+        return null;
+    return path.relative(root, absolute).split(path.sep).join('/');
+}
+function collectFiles(dirPath, predicate) {
+    if (!fs.existsSync(dirPath))
+        return [];
+    const root = path.resolve(dirPath);
+    const output = [];
+    const visit = (currentPath) => {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const absolutePath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                visit(absolutePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const relativePath = path.relative(root, absolutePath).split(path.sep).join('/');
+            if (predicate(absolutePath, relativePath))
+                output.push(absolutePath);
+        }
+    };
+    visit(root);
+    return output;
+}
+function readFileFingerprint(absolutePath) {
+    try {
+        const stat = fs.statSync(absolutePath);
+        if (!stat.isFile())
+            return null;
+        const buffer = fs.readFileSync(absolutePath);
+        return {
+            sha256: createHash('sha256').update(buffer).digest('hex'),
+            sizeBytes: buffer.length,
+            updatedAt: Number.isFinite(stat.mtimeMs) ? new Date(stat.mtimeMs).toISOString() : new Date().toISOString()
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function extensionToMimeType(relativePath) {
+    const lower = relativePath.toLowerCase();
+    if (lower.endsWith('.png'))
+        return 'image/png';
+    if (lower.endsWith('.jpg') || lower.endsWith('.jpeg'))
+        return 'image/jpeg';
+    if (lower.endsWith('.gif'))
+        return 'image/gif';
+    if (lower.endsWith('.webp'))
+        return 'image/webp';
+    if (lower.endsWith('.svg'))
+        return 'image/svg+xml';
+    if (lower.endsWith('.pdf'))
+        return 'application/pdf';
+    if (lower.endsWith('.json'))
+        return 'application/json';
+    if (lower.endsWith('.txt'))
+        return 'text/plain';
+    if (lower.endsWith('.md') || lower.endsWith('.markdown'))
+        return 'text/markdown';
+    return 'application/octet-stream';
+}
+function isMarkdownPath(relativePath) {
+    const lower = relativePath.toLowerCase();
+    return lower.endsWith('.md') || lower.endsWith('.markdown');
+}
+function isWorkspaceBinaryAssetPath(relativePath, workspaceId) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (!normalized.startsWith(`workspaces/${workspaceId}/assets/`))
+        return false;
+    return !normalized.startsWith(`workspaces/${workspaceId}/assets/documents/`);
+}
+function isWorkspaceDocumentPath(relativePath, workspaceId) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (normalized.startsWith(`workspaces/${workspaceId}/assets/documents/`))
+        return isMarkdownPath(normalized);
+    return normalized.startsWith('docs/') && isMarkdownPath(normalized);
+}
+function getPrimaryTaskId(store, assetId, workspaceId) {
+    const links = store.listLinksForAsset(assetId, workspaceId, { includeDeleted: false });
+    return links[0]?.taskId || null;
+}
+function buildManifestEntriesFromMetadata(workspaceId, store, basePath) {
+    const documentEntries = [];
+    const documentDeletes = [];
+    const assetEntries = [];
+    const assetDeletes = [];
+    const metadataEntries = store.listAllByWorkspace(workspaceId, { includeDeleted: true });
+    for (const entry of metadataEntries) {
+        const localPath = path.resolve(basePath, entry.storageKey);
+        const existsLocally = entry.storageProvider === 'local' ? fs.existsSync(localPath) : true;
+        if (entry.kind === 'document') {
+            if (entry.deletedAt) {
+                documentDeletes.push({
+                    key: entry.storageKey,
+                    deletedAt: entry.deletedAt
+                });
+                continue;
+            }
+            documentEntries.push({
+                path: entry.storageKey,
+                assetId: entry.assetId,
+                taskId: getPrimaryTaskId(store, entry.assetId, workspaceId),
+                updatedAt: String(entry.updatedAt || entry.createdAt || '').trim(),
+                deletedAt: entry.deletedAt,
+                sha256: String(entry.contentSha256 || '').trim(),
+                sizeBytes: Number(entry.sizeBytes || 0),
+                existsLocally,
+                source: 'metadata'
+            });
+            continue;
+        }
+        if (entry.kind !== 'image' && entry.kind !== 'file')
+            continue;
+        if (entry.deletedAt) {
+            assetDeletes.push({
+                key: entry.storageKey,
+                deletedAt: entry.deletedAt
+            });
+            continue;
+        }
+        assetEntries.push({
+            path: entry.storageKey,
+            assetId: entry.assetId,
+            taskId: getPrimaryTaskId(store, entry.assetId, workspaceId),
+            kind: entry.kind === 'image' ? 'image' : 'file',
+            updatedAt: String(entry.updatedAt || entry.createdAt || '').trim(),
+            deletedAt: entry.deletedAt,
+            sha256: String(entry.contentSha256 || '').trim(),
+            sizeBytes: Number(entry.sizeBytes || 0),
+            existsLocally,
+            source: 'metadata'
+        });
+    }
+    return { documents: documentEntries, documentDeletes, assets: assetEntries, assetDeletes };
+}
+export function buildWorkspaceRepairManifest(input) {
+    const workspaceId = normalizeWorkspaceId(input.workspaceId);
+    const basePath = path.resolve(input.basePath);
+    const generatedAt = new Date().toISOString();
+    const { workspaceAssetStore } = input;
+    const metadataSnapshot = workspaceAssetStore
+        ? buildManifestEntriesFromMetadata(workspaceId, workspaceAssetStore, basePath)
+        : { documents: [], documentDeletes: [], assets: [], assetDeletes: [] };
+    const documentsByPath = new Map(metadataSnapshot.documents.map((entry) => [entry.path, entry]));
+    const assetsByPath = new Map(metadataSnapshot.assets.map((entry) => [entry.path, entry]));
+    const documentRoots = [
+        path.join(basePath, 'docs'),
+        path.join(basePath, 'workspaces', workspaceId, 'assets', 'documents')
+    ];
+    for (const rootPath of documentRoots) {
+        const files = collectFiles(rootPath, (absolutePath) => {
+            const relativePath = toRelativeWorkspacePath(basePath, absolutePath);
+            return Boolean(relativePath && isWorkspaceDocumentPath(relativePath, workspaceId));
+        });
+        for (const absolutePath of files) {
+            const relativePath = toRelativeWorkspacePath(basePath, absolutePath);
+            if (!relativePath || documentsByPath.has(relativePath))
+                continue;
+            const fingerprint = readFileFingerprint(absolutePath);
+            if (!fingerprint)
+                continue;
+            documentsByPath.set(relativePath, {
+                path: relativePath,
+                assetId: null,
+                taskId: null,
+                updatedAt: fingerprint.updatedAt,
+                deletedAt: null,
+                sha256: fingerprint.sha256,
+                sizeBytes: fingerprint.sizeBytes,
+                existsLocally: true,
+                source: 'filesystem'
+            });
+        }
+    }
+    const assetRoot = path.join(basePath, 'workspaces', workspaceId, 'assets');
+    const assetFiles = collectFiles(assetRoot, (absolutePath) => {
+        const relativePath = toRelativeWorkspacePath(basePath, absolutePath);
+        return Boolean(relativePath && isWorkspaceBinaryAssetPath(relativePath, workspaceId));
+    });
+    for (const absolutePath of assetFiles) {
+        const relativePath = toRelativeWorkspacePath(basePath, absolutePath);
+        if (!relativePath || assetsByPath.has(relativePath))
+            continue;
+        const fingerprint = readFileFingerprint(absolutePath);
+        if (!fingerprint)
+            continue;
+        assetsByPath.set(relativePath, {
+            path: relativePath,
+            assetId: null,
+            taskId: null,
+            kind: extensionToMimeType(relativePath).startsWith('image/') ? 'image' : 'file',
+            updatedAt: fingerprint.updatedAt,
+            deletedAt: null,
+            sha256: fingerprint.sha256,
+            sizeBytes: fingerprint.sizeBytes,
+            existsLocally: true,
+            source: 'filesystem'
+        });
+    }
+    return {
+        workspaceId,
+        generatedAt,
+        tasks: [
+            ...(input.tasks || []).map((task) => ({
+                id: String(task.id || '').trim(),
+                archived: false,
+                updatedAt: String(task.updatedAt || '').trim(),
+                createdAt: String(task.createdAt || '').trim(),
+                attachmentCount: Array.isArray(task.attachments) ? task.attachments.length : 0
+            })),
+            ...(input.archivedTasks || []).map((task) => ({
+                id: String(task.id || '').trim(),
+                archived: true,
+                updatedAt: String(task.updatedAt || '').trim(),
+                createdAt: String(task.createdAt || '').trim(),
+                attachmentCount: Array.isArray(task.attachments) ? task.attachments.length : 0
+            }))
+        ].filter((task) => task.id.length > 0).sort((a, b) => a.id.localeCompare(b.id)),
+        deletedTasks: (input.deletedTasks || [])
+            .map((entry) => ({
+            key: String(entry.taskId || '').trim(),
+            deletedAt: String(entry.deletedAt || '').trim()
+        }))
+            .filter((entry) => entry.key.length > 0 && entry.deletedAt.length > 0)
+            .sort((a, b) => a.key.localeCompare(b.key)),
+        documents: Array.from(documentsByPath.values()).sort((a, b) => a.path.localeCompare(b.path)),
+        documentDeletes: metadataSnapshot.documentDeletes.sort((a, b) => a.key.localeCompare(b.key)),
+        assets: Array.from(assetsByPath.values()).sort((a, b) => a.path.localeCompare(b.path)),
+        assetDeletes: metadataSnapshot.assetDeletes.sort((a, b) => a.key.localeCompare(b.key))
+    };
+}
+export function scanWorkspaceRepair(input) {
+    const snapshot = buildWorkspaceRepairManifest(input);
+    const issues = [];
+    const activeTaskIds = new Set(snapshot.tasks.map((task) => task.id));
+    const documentDeleteByPath = new Map(snapshot.documentDeletes.map((entry) => [entry.key, entry.deletedAt]));
+    const assetDeleteByPath = new Map(snapshot.assetDeletes.map((entry) => [entry.key, entry.deletedAt]));
+    for (const document of snapshot.documents) {
+        if (!document.assetId) {
+            const deletedAt = documentDeleteByPath.get(document.path) || '';
+            if (deletedAt) {
+                const compare = compareWorkspaceMutationOrdering(document.updatedAt, deletedAt, document.sha256, document.path);
+                if (compare > 0) {
+                    issues.push({
+                        code: 'stale_document_tombstone',
+                        entityKind: 'document',
+                        path: document.path,
+                        repairable: true,
+                        recommendedAction: 'revive-metadata',
+                        detail: 'Local document file is newer than the deleted metadata tombstone.'
+                    });
+                }
+                continue;
+            }
+            issues.push({
+                code: 'missing_document_metadata',
+                entityKind: 'document',
+                path: document.path,
+                repairable: true,
+                recommendedAction: 'create-metadata',
+                detail: 'Local markdown document exists without canonical workspace asset metadata.'
+            });
+            continue;
+        }
+        if (!document.existsLocally) {
+            issues.push({
+                code: 'missing_document_file',
+                entityKind: 'document',
+                path: document.path,
+                assetId: document.assetId,
+                repairable: true,
+                recommendedAction: 'mark-deleted',
+                detail: 'Canonical document metadata exists but the local document file is missing.'
+            });
+        }
+    }
+    for (const asset of snapshot.assets) {
+        if (!asset.assetId) {
+            const deletedAt = assetDeleteByPath.get(asset.path) || '';
+            if (deletedAt) {
+                const compare = compareWorkspaceMutationOrdering(asset.updatedAt, deletedAt, asset.sha256, asset.path);
+                if (compare > 0) {
+                    issues.push({
+                        code: 'stale_asset_tombstone',
+                        entityKind: 'asset',
+                        path: asset.path,
+                        repairable: true,
+                        recommendedAction: 'revive-metadata',
+                        detail: 'Local binary asset file is newer than the deleted metadata tombstone.'
+                    });
+                }
+                continue;
+            }
+            issues.push({
+                code: 'missing_asset_metadata',
+                entityKind: 'asset',
+                path: asset.path,
+                repairable: true,
+                recommendedAction: 'create-metadata',
+                detail: 'Local binary asset exists without canonical workspace asset metadata.'
+            });
+            continue;
+        }
+        if (!asset.existsLocally) {
+            issues.push({
+                code: 'missing_asset_file',
+                entityKind: 'asset',
+                path: asset.path,
+                assetId: asset.assetId,
+                repairable: true,
+                recommendedAction: 'mark-deleted',
+                detail: 'Canonical binary asset metadata exists but the local asset file is missing.'
+            });
+        }
+    }
+    if (input.workspaceAssetStore) {
+        const assets = input.workspaceAssetStore.listAllByWorkspace(snapshot.workspaceId, { includeDeleted: false });
+        for (const asset of assets) {
+            const links = input.workspaceAssetStore.listLinksForAsset(asset.assetId, snapshot.workspaceId, { includeDeleted: false });
+            for (const link of links) {
+                if (activeTaskIds.has(link.taskId))
+                    continue;
+                issues.push({
+                    code: 'stale_asset_link',
+                    entityKind: 'link',
+                    path: asset.storageKey,
+                    assetId: asset.assetId,
+                    taskId: link.taskId,
+                    role: link.role,
+                    repairable: true,
+                    recommendedAction: 'delete-link',
+                    detail: 'Canonical asset link points to a task that no longer exists in this workspace.'
+                });
+            }
+        }
+    }
+    const byCode = {};
+    for (const issue of issues)
+        byCode[issue.code] = (byCode[issue.code] || 0) + 1;
+    return {
+        workspaceId: snapshot.workspaceId,
+        generatedAt: snapshot.generatedAt,
+        snapshot,
+        issues,
+        summary: {
+            totalIssues: issues.length,
+            repairableIssues: issues.filter((issue) => issue.repairable).length,
+            byCode
+        }
+    };
+}
+function upsertRecoveredDocumentMetadata(input) {
+    const absolutePath = path.resolve(input.basePath, input.relativePath);
+    const fingerprint = readFileFingerprint(absolutePath);
+    if (!fingerprint)
+        return false;
+    const existing = input.existingDeletedAsset;
+    input.workspaceAssetStore.upsertAsset({
+        assetId: String(existing?.assetId || `asset-${randomUUID().replace(/-/g, '')}`),
+        workspaceId: input.workspaceId,
+        kind: 'document',
+        logicalName: existing?.logicalName || null,
+        originalFilename: existing?.originalFilename || path.basename(input.relativePath) || 'document.md',
+        mimeType: existing?.mimeType || 'text/markdown',
+        storageProvider: 'local',
+        storageKey: input.relativePath,
+        contentSha256: fingerprint.sha256,
+        sizeBytes: fingerprint.sizeBytes,
+        documentId: existing?.documentId || `doc-${randomUUID().replace(/-/g, '')}`,
+        version: Math.max(1, Number(existing?.version || 0) + 1),
+        isLatest: true,
+        scanStatus: existing?.scanStatus || 'clean',
+        scanEngine: existing?.scanEngine || null,
+        scanDetails: existing?.scanDetails || null,
+        createdByUserId: existing?.createdByUserId || null,
+        createdAt: existing?.createdAt || fingerprint.updatedAt,
+        updatedAt: fingerprint.updatedAt,
+        deletedAt: null,
+        purgeAfter: null
+    });
+    input.upsertDocumentWatermark(input.workspaceId, input.relativePath, fingerprint.sha256, fingerprint.updatedAt);
+    return true;
+}
+function upsertRecoveredBinaryAssetMetadata(input) {
+    const absolutePath = path.resolve(input.basePath, input.relativePath);
+    const fingerprint = readFileFingerprint(absolutePath);
+    if (!fingerprint)
+        return false;
+    const existing = input.existingDeletedAsset;
+    const mimeType = existing?.mimeType || extensionToMimeType(input.relativePath);
+    input.workspaceAssetStore.upsertAsset({
+        assetId: String(existing?.assetId || `asset-${randomUUID().replace(/-/g, '')}`),
+        workspaceId: input.workspaceId,
+        kind: mimeType.startsWith('image/') ? 'image' : 'file',
+        logicalName: existing?.logicalName || null,
+        originalFilename: existing?.originalFilename || path.basename(input.relativePath) || 'asset',
+        mimeType,
+        storageProvider: 'local',
+        storageKey: input.relativePath,
+        contentSha256: fingerprint.sha256,
+        sizeBytes: fingerprint.sizeBytes,
+        documentId: null,
+        version: existing?.version || null,
+        isLatest: true,
+        scanStatus: existing?.scanStatus || 'clean',
+        scanEngine: existing?.scanEngine || null,
+        scanDetails: existing?.scanDetails || null,
+        createdByUserId: existing?.createdByUserId || null,
+        createdAt: existing?.createdAt || fingerprint.updatedAt,
+        updatedAt: fingerprint.updatedAt,
+        deletedAt: null,
+        purgeAfter: null
+    });
+    return true;
+}
+export function applyWorkspaceRepair(input) {
+    const scan = scanWorkspaceRepair(input);
+    const actionsApplied = [];
+    const workspaceId = normalizeWorkspaceId(input.workspaceId);
+    const deletedMetadataByPath = new Map();
+    if (input.workspaceAssetStore) {
+        for (const entry of input.workspaceAssetStore.listAllByWorkspace(workspaceId, { includeDeleted: true })) {
+            if (!entry.deletedAt)
+                continue;
+            deletedMetadataByPath.set(entry.storageKey, entry);
+        }
+    }
+    for (const issue of scan.issues) {
+        if (!issue.repairable) {
+            actionsApplied.push({
+                code: issue.code,
+                path: issue.path,
+                assetId: issue.assetId,
+                taskId: issue.taskId,
+                action: issue.recommendedAction,
+                status: 'skipped',
+                detail: 'Issue is not automatically repairable.'
+            });
+            continue;
+        }
+        try {
+            if (!input.workspaceAssetStore) {
+                actionsApplied.push({
+                    code: issue.code,
+                    path: issue.path,
+                    assetId: issue.assetId,
+                    taskId: issue.taskId,
+                    action: issue.recommendedAction,
+                    status: 'skipped',
+                    detail: 'Workspace asset store is unavailable in this runtime.'
+                });
+                continue;
+            }
+            if ((issue.code === 'missing_document_metadata' || issue.code === 'stale_document_tombstone') && issue.path) {
+                const applied = upsertRecoveredDocumentMetadata({
+                    workspaceId,
+                    basePath: input.basePath,
+                    relativePath: issue.path,
+                    workspaceAssetStore: input.workspaceAssetStore,
+                    existingDeletedAsset: deletedMetadataByPath.get(issue.path) || null,
+                    upsertDocumentWatermark: input.upsertDocumentWatermark
+                });
+                actionsApplied.push({
+                    code: issue.code,
+                    path: issue.path,
+                    action: issue.recommendedAction,
+                    status: applied ? 'applied' : 'failed',
+                    detail: applied ? 'Recreated canonical document metadata from the local file.' : 'Failed to read the local document file.'
+                });
+                continue;
+            }
+            if ((issue.code === 'missing_asset_metadata' || issue.code === 'stale_asset_tombstone') && issue.path) {
+                const applied = upsertRecoveredBinaryAssetMetadata({
+                    workspaceId,
+                    basePath: input.basePath,
+                    relativePath: issue.path,
+                    workspaceAssetStore: input.workspaceAssetStore,
+                    existingDeletedAsset: deletedMetadataByPath.get(issue.path) || null
+                });
+                actionsApplied.push({
+                    code: issue.code,
+                    path: issue.path,
+                    action: issue.recommendedAction,
+                    status: applied ? 'applied' : 'failed',
+                    detail: applied ? 'Recreated canonical binary asset metadata from the local file.' : 'Failed to read the local asset file.'
+                });
+                continue;
+            }
+            if ((issue.code === 'missing_document_file' || issue.code === 'missing_asset_file') && issue.assetId) {
+                const updated = input.workspaceAssetStore.markDeleted(issue.assetId, workspaceId);
+                actionsApplied.push({
+                    code: issue.code,
+                    path: issue.path,
+                    assetId: issue.assetId,
+                    action: issue.recommendedAction,
+                    status: updated ? 'applied' : 'failed',
+                    detail: updated ? 'Marked stale canonical metadata deleted because the local file is missing.' : 'Failed to mark canonical metadata deleted.'
+                });
+                continue;
+            }
+            if (issue.code === 'stale_asset_link' && issue.assetId && issue.taskId && issue.role) {
+                const deleted = input.workspaceAssetStore.deleteLink({
+                    workspaceId,
+                    assetId: issue.assetId,
+                    taskId: issue.taskId,
+                    role: issue.role
+                });
+                actionsApplied.push({
+                    code: issue.code,
+                    path: issue.path,
+                    assetId: issue.assetId,
+                    taskId: issue.taskId,
+                    action: issue.recommendedAction,
+                    status: deleted ? 'applied' : 'failed',
+                    detail: deleted ? 'Removed the stale canonical asset link for a missing task.' : 'Failed to remove the stale canonical asset link.'
+                });
+                continue;
+            }
+            actionsApplied.push({
+                code: issue.code,
+                path: issue.path,
+                assetId: issue.assetId,
+                taskId: issue.taskId,
+                action: issue.recommendedAction,
+                status: 'skipped',
+                detail: 'No automatic repair handler is available for this issue.'
+            });
+        }
+        catch (error) {
+            actionsApplied.push({
+                code: issue.code,
+                path: issue.path,
+                assetId: issue.assetId,
+                taskId: issue.taskId,
+                action: issue.recommendedAction,
+                status: 'failed',
+                detail: String(error?.message || error || 'Unknown repair failure.')
+            });
+        }
+    }
+    const refreshed = scanWorkspaceRepair(input);
+    return {
+        ...refreshed,
+        actionsApplied
+    };
+}