devchain-cli 0.24.0 → 0.24.2

package/dist/server/modules/remotes/operations/file-sync-handoff.js

@@ -11,13 +11,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSyncHandoff = exports.FileSyncNotConnectedError = void 0;
 const common_1 = require("@nestjs/common");
+const git_owner_store_1 = require("../git-owner.store");
+const node_os_1 = require("node:os");
 const error_types_1 = require("../../../common/errors/error-types");
 const logger_1 = require("../../../common/logging/logger");
 const file_sync_dto_1 = require("../../file-sync/file-sync.dto");
 const file_sync_service_1 = require("../../file-sync/file-sync.service");
 const file_sync_managed_exclusions_store_1 = require("../../file-sync/file-sync-managed-exclusions.store");
 const home_git_guard_service_1 = require("../../file-sync/home-git-guard.service");
+const project_repository_1 = require("../../file-sync/project-repository");
 const syncthing_rest_client_1 = require("../../file-sync/syncthing-rest.client");
+const process_executor_port_1 = require("../../terminal/services/process-executor/process-executor.port");
 const remote_host_client_1 = require("./remote-host.client");
 const syncthing_temp_cleanup_1 = require("./syncthing-temp-cleanup");
 const logger = (0, logger_1.createLogger)('FileSyncHandoff');
@@ -30,22 +34,236 @@ class FileSyncNotConnectedError extends error_types_1.AppError {
     }
 }
 exports.FileSyncNotConnectedError = FileSyncNotConnectedError;
+const SIDE_NAMES = { home: 'this PC', host: 'the VM' };
+function forceErrors(status) {
+    const failures = (status.fileErrors ?? []).filter((file) => !(0, file_sync_dto_1.isTransientSyncError)(file.error));
+    return {
+        failures,
+        failed: failures.length > 0 ||
+            (status.errors ?? 0) > (status.fileErrors?.length ?? 0) ||
+            (!!status.error && !(0, file_sync_dto_1.isTransientSyncError)(status.error)),
+    };
+}
 let FileSyncHandoff = class FileSyncHandoff {
     fileSync;
     host;
     managedExclusions;
     guard;
-    constructor(fileSync, host, managedExclusions, guard) {
+    processExecutor;
+    gitOwner;
+    active = new Map();
+    constructor(fileSync, host, managedExclusions, guard, processExecutor, gitOwner) {
         this.fileSync = fileSync;
         this.host = host;
         this.managedExclusions = managedExclusions;
         this.guard = guard;
+        this.processExecutor = processExecutor;
+        this.gitOwner = gitOwner;
+    }
+    interrupt(operationId, reason = 'The Connect was cancelled.') {
+        this.active.get(operationId)?.abort(new Error(reason));
     }
     async initial(run, projectId) {
+        const controller = new AbortController();
+        this.active.set(run.operation.id, controller);
+        try {
+            const { remoteId } = run.operation;
+            const ignores = this.syncIgnores(projectId);
+            const { removed } = await this.host.removeGitGuard(remoteId, projectId);
+            if (removed)
+                await run.progress({ vmGuardRemoved: true });
+            controller.signal.throwIfAborted();
+            const codeId = (0, file_sync_service_1.codeFolderId)(projectId);
+            if (run.details.fileSyncMode !== 'merge' && run.details.fileSyncMode !== 'reset') {
+                const [homeFolders, hostExists] = await Promise.all([
+                    this.fileSync.projectFolders(projectId),
+                    this.host.syncFolderExists(remoteId, codeId),
+                ]);
+                await run.progress({
+                    fileSyncMode: hostExists && homeFolders.some((folder) => folder.id === codeId) ? 'merge' : 'reset',
+                }, { durable: true });
+            }
+            controller.signal.throwIfAborted();
+            const merge = run.details.fileSyncMode === 'merge';
+            const devices = await this.pair(remoteId, controller.signal);
+            const folders = await this.fileSync.initialFolders(projectId);
+            for (const folder of folders) {
+                const request = {
+                    projectId,
+                    kind: folder.kind,
+                    ignores: folder.kind === 'code' ? ignores : (0, file_sync_dto_1.gitIgnores)(false),
+                    paused: true,
+                };
+                const mergeCode = merge && folder.kind === 'code';
+                if (mergeCode)
+                    await this.fileSync.updateFolder(folder.id, { paused: true });
+                else
+                    await this.fileSync.ensureFolder({
+                        ...request,
+                        type: 'sendonly',
+                        peerDeviceId: devices.host,
+                    });
+                await this.host.syncFolders(remoteId, {
+                    ...request,
+                    type: mergeCode ? 'sendreceive' : 'receiveonly',
+                    peerDeviceId: devices.home,
+                });
+            }
+            if (merge) {
+                await this.host.syncFolderType(remoteId, codeId, { paused: false });
+                await this.host.syncScan(remoteId, codeId);
+                await this.waitHostIdle(remoteId, codeId, controller.signal);
+                if (run.details.vmEdits === undefined &&
+                    run.details.fileSyncConflictBaseline === undefined) {
+                    const vmEdits = await this.host.syncRemoteNeed(remoteId, codeId, devices.home);
+                    const homeBaseline = await this.fileSync.conflictBaseline(projectId, ignores, controller.signal);
+                    const paths = new Set([
+                        ...vmEdits.conflictPaths,
+                        ...(homeBaseline.baselineOverCap ? [] : homeBaseline.paths),
+                    ]);
+                    const fileSyncConflictBaseline = homeBaseline.baselineOverCap ||
+                        vmEdits.conflictsOverCap ||
+                        paths.size > file_sync_dto_1.CONFLICT_BASELINE_MAX
+                        ? { baselineOverCap: true }
+                        : { baselineOverCap: false, paths: [...paths] };
+                    await run.progress({ vmEdits, fileSyncConflictBaseline }, { durable: true });
+                }
+                else {
+                    file_sync_dto_1.RemoteNeedSchema.parse(run.details.vmEdits);
+                    file_sync_dto_1.ConflictBaselineSchema.parse(run.details.fileSyncConflictBaseline);
+                }
+                controller.signal.throwIfAborted();
+                await this.fileSync.ensureFolder({
+                    projectId,
+                    kind: 'code',
+                    ignores,
+                    paused: true,
+                    type: 'sendreceive',
+                    peerDeviceId: devices.host,
+                });
+            }
+            await this.unpauseAll(remoteId, folders);
+            await this.waitAll(run, folders, {
+                sender: 'home',
+                devices,
+                symmetricCode: merge,
+                signal: controller.signal,
+            });
+            if (merge) {
+                const fileSyncConflicts = await this.fileSync.conflicts(projectId, file_sync_dto_1.ConflictBaselineSchema.parse(run.details.fileSyncConflictBaseline), ignores, controller.signal);
+                await run.progress({ fileSyncConflicts });
+            }
+        }
+        finally {
+            if (this.active.get(run.operation.id) === controller)
+                this.active.delete(run.operation.id);
+        }
+    }
+    async ensureAvailable() {
+        await this.fileSync.ensureAvailable();
+    }
+    async ensureRepository(projectId) {
+        const root = await this.fileSync.folderPath(projectId);
+        if ((await (0, project_repository_1.projectRepository)(root)) !== 'missing')
+            return false;
+        const result = await this.processExecutor.run({
+            argv: ['git', 'init'],
+            mode: 'pipe',
+            cwd: root,
+            timeout: 30_000,
+        });
+        if (!result.success) {
+            throw new error_types_1.AppError(result.stderr.trim() ||
+                result.stdout.trim() ||
+                'Could not create a Git repository on this PC.', 'GIT_INIT_FAILED', 500);
+        }
+        return true;
+    }
+    async flipToHost(run, projectId) {
         const { remoteId } = run.operation;
-        const ignores = this.syncIgnores(projectId);
+        const folders = await this.fileSync.projectFolders(projectId);
+        await this.hostDirections(remoteId, folders, 'vm', false);
+        if (folders.some((folder) => folder.kind === 'git')) {
+            const guardWarning = await this.guard.install(projectId, remoteId);
+            if (guardWarning)
+                await run.progress({ guardWarning });
+        }
+    }
+    async settleGit(run, projectId, owner) {
+        const controller = new AbortController();
+        const { remoteId, id } = run.operation;
+        this.active.set(id, controller);
+        try {
+            const devices = await this.pair(remoteId, controller.signal);
+            const folders = (0, file_sync_service_1.projectFolderList)(projectId, ['git']);
+            const config = owner === 'vm'
+                ? await this.fileSync.folderConfiguration(folders[0].id)
+                : await this.host.syncFolderConfiguration(remoteId, folders[0].id);
+            controller.signal.throwIfAborted();
+            if (config.type !== 'receiveonly' || config.paused)
+                throw new error_types_1.AppError('The receiving Git folder is not ready. Retry the switch.', 'GIT_SWITCH_RECEIVER_NOT_READY', 409);
+            await this.waitAll(run, folders, {
+                sender: owner === 'vm' ? 'host' : 'home',
+                devices,
+                requireNoReceiveOnlyChanges: true,
+                revertAfterComplete: true,
+                signal: controller.signal,
+            });
+        }
+        finally {
+            if (this.active.get(id) === controller)
+                this.active.delete(id);
+        }
+    }
+    async flipGit(run, projectId, owner) {
+        const { remoteId } = run.operation;
+        const folderId = (0, file_sync_service_1.projectFolderId)(projectId, 'git');
+        const ignores = (0, file_sync_dto_1.gitIgnores)(true);
+        if (owner === 'home') {
+            await this.host.syncFolderType(remoteId, folderId, { type: 'receiveonly', ignores });
+            await this.fileSync.updateFolder(folderId, { type: 'sendonly', ignores });
+        }
+        else {
+            await this.fileSync.updateFolder(folderId, { type: 'receiveonly', ignores });
+            await this.host.syncFolderType(remoteId, folderId, { type: 'sendonly', ignores });
+        }
+        this.gitOwner.set(projectId, owner);
+        await this.host.syncFolderType(remoteId, folderId, { paused: false });
+        await this.fileSync.updateFolder(folderId, { paused: false });
+    }
+    async forceCopy(run, projectId, source, kinds) {
+        const { remoteId, id: operationId } = run.operation;
+        const folders = (0, file_sync_service_1.projectFolderList)(projectId, kinds);
+        const sender = source === 'home' ? 'home' : 'host';
+        const receiver = sender === 'home' ? 'host' : 'home';
+        const backups = [];
+        for (const folder of folders) {
+            const request = { projectId, kind: folder.kind, forceCopy: { operationId } };
+            const { path } = receiver === 'home'
+                ? await this.fileSync.forceCopyBackup(request)
+                : await this.host.syncForceCopyBackup(remoteId, request);
+            backups.push({ side: receiver === 'home' ? 'home' : 'vm', kind: folder.kind, path });
+        }
+        await this.forceProgress(run, { backups, verified: false });
+        await this.guard.remove(projectId, { refreshIndex: false });
+        await this.host.removeGitGuard(remoteId, projectId);
+        for (const folder of folders) {
+            for (const side of ['home', 'host']) {
+                try {
+                    if (side === 'home')
+                        await this.fileSync.removeFolder(folder.id);
+                    else
+                        await this.host.syncRemoveFolder(remoteId, folder.id);
+                }
+                catch (error) {
+                    if (!((error instanceof syncthing_rest_client_1.SyncthingRestError || error instanceof remote_host_client_1.RemoteHostRequestError) &&
+                        error.status === 404))
+                        throw error;
+                }
+            }
+        }
         const devices = await this.pair(remoteId);
-        const folders = await this.fileSync.initialFolders(projectId);
+        const ignores = this.syncIgnores(projectId);
         for (const folder of folders) {
             const request = {
                 projectId,
@@ -55,33 +273,167 @@ let FileSyncHandoff = class FileSyncHandoff {
             };
             await this.fileSync.ensureFolder({
                 ...request,
-                type: 'sendonly',
+                type: sender === 'home' ? 'sendonly' : 'receiveonly',
                 peerDeviceId: devices.host,
+                ...(receiver === 'home' && { forceCopy: { operationId } }),
             });
             await this.host.syncFolders(remoteId, {
                 ...request,
-                type: 'receiveonly',
+                type: sender === 'host' ? 'sendonly' : 'receiveonly',
                 peerDeviceId: devices.home,
+                ...(receiver === 'host' && { forceCopy: { operationId } }),
             });
         }
         await this.unpauseAll(remoteId, folders);
-        await this.waitAll(run, folders, { sender: 'home', devices });
-    }
-    async ensureAvailable() {
-        await this.fileSync.ensureAvailable();
+        for (const folder of folders) {
+            await Promise.all([
+                this.scan(sender, remoteId, folder.id),
+                this.scan(receiver, remoteId, folder.id),
+            ]);
+        }
+        for (const folder of folders) {
+            await this.waitBarrier(remoteId, folder.id, sender);
+            if (sender === 'home')
+                await this.fileSync.override(folder.id);
+            else
+                await this.host.syncOverride(remoteId, folder.id);
+        }
+        const replaced = { count: 0, sample: [] };
+        for (const folder of folders) {
+            const changed = receiver === 'home'
+                ? await this.fileSync.localChanges(folder.id)
+                : await this.host.syncLocalChanges(remoteId, folder.id);
+            replaced.count += changed.count;
+            replaced.sample.push(...changed.sample
+                .slice(0, file_sync_dto_1.RECEIVE_ONLY_SAMPLE_MAX - replaced.sample.length)
+                .map((name) => (folder.kind === 'git' ? `.git/${name}` : name)));
+        }
+        const earlier = this.forceDetails(run).replaced;
+        if (earlier) {
+            replaced.count = Math.max(replaced.count, earlier.count);
+            replaced.sample = [...new Set([...earlier.sample, ...replaced.sample])].slice(0, file_sync_dto_1.RECEIVE_ONLY_SAMPLE_MAX);
+        }
+        await this.forceProgress(run, { replaced });
+        let waitError;
+        try {
+            await this.waitAll(run, folders, {
+                sender,
+                devices,
+                symmetricCode: false,
+                requireNoReceiveOnlyChanges: true,
+            });
+        }
+        catch (error) {
+            waitError = error;
+        }
+        await this.verifyForceCopy(remoteId, folders, sender, devices);
+        if (waitError)
+            throw waitError;
+        await this.forceProgress(run, { verified: true });
     }
-    async flipToHost(run, projectId) {
+    async restoreConnected(run, projectId, kinds) {
+        if (this.forceDetails(run).verified !== true)
+            throw new error_types_1.AppError('Force sync has not verified the copy.', 'FORCE_SYNC_NOT_VERIFIED', 409);
         const { remoteId } = run.operation;
-        const folders = await this.fileSync.projectFolders(projectId);
-        await this.hostDirections(remoteId, folders, false);
-        if (folders.some((folder) => folder.kind === 'git')) {
-            const guardWarning = await this.guard.install(projectId, remoteId);
-            if (guardWarning)
-                await run.progress({ guardWarning });
+        const owner = this.gitOwner.get(projectId);
+        const devices = await this.pair(remoteId);
+        const folders = (0, file_sync_service_1.projectFolderList)(projectId, kinds);
+        const ignores = this.syncIgnores(projectId);
+        for (const folder of folders) {
+            const request = {
+                projectId,
+                kind: folder.kind,
+                ignores: folder.kind === 'code' ? ignores : (0, file_sync_dto_1.gitIgnores)(true),
+                paused: true,
+            };
+            const ensureHome = () => this.fileSync.ensureFolder({
+                ...request,
+                type: folder.kind === 'code' ? 'sendreceive' : owner === 'home' ? 'sendonly' : 'receiveonly',
+                peerDeviceId: devices.host,
+            });
+            const ensureHost = () => this.host.syncFolders(remoteId, {
+                ...request,
+                type: folder.kind === 'code' ? 'sendreceive' : owner === 'vm' ? 'sendonly' : 'receiveonly',
+                peerDeviceId: devices.home,
+            });
+            if (folder.kind === 'git' && owner === 'home') {
+                await ensureHost();
+                await ensureHome();
+            }
+            else {
+                await ensureHome();
+                await ensureHost();
+            }
+        }
+        await this.unpauseAll(remoteId, folders);
+        if (kinds.includes('git')) {
+            if (owner === 'vm') {
+                const guardWarning = await this.guard.install(projectId, remoteId);
+                if (guardWarning)
+                    await run.progress({ guardWarning });
+            }
+            else {
+                const { warning } = await this.host.installGitGuard(remoteId, projectId, {
+                    homeName: (0, node_os_1.hostname)(),
+                    reason: 'pc-git',
+                });
+                await run.progress({ vmGuardWarning: warning });
+            }
         }
     }
+    forceDetails(run) {
+        const value = run.details.forceSync;
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    forceProgress(run, patch) {
+        return run.progress({ forceSync: { ...this.forceDetails(run), ...patch } }, { durable: true });
+    }
+    async waitBarrier(remoteId, folderId, sender) {
+        const receiver = sender === 'home' ? 'host' : 'home';
+        const deadline = Date.now() + SYNC_TIMEOUT_MS;
+        for (;;) {
+            const [source, target] = await Promise.all([
+                this.status(sender, remoteId, folderId),
+                this.status(receiver, remoteId, folderId),
+            ]);
+            if ((0, file_sync_service_1.senderIndexReached)(source, target))
+                return;
+            if (Date.now() >= deadline)
+                throw new file_sync_service_1.FileSyncTimeoutError(folderId, null, 'The source index did not reach the receiver.');
+            await sleep(POLL_MS);
+        }
+    }
+    async verifyForceCopy(remoteId, folders, sender, devices) {
+        const receiver = sender === 'home' ? 'host' : 'home';
+        const problems = [];
+        const failedFiles = [];
+        for (const folder of folders) {
+            const [source, target] = await Promise.all([
+                this.status(sender, remoteId, folder.id, devices[receiver], { allErrors: true }),
+                this.status(receiver, remoteId, folder.id, undefined, { allErrors: true }),
+            ]);
+            const targetErrors = forceErrors(target);
+            failedFiles.push(...targetErrors.failures
+                .slice(0, 3 - failedFiles.length)
+                .map((file) => `${folder.id}/${file.path}: ${file.error}`));
+            if (!(0, file_sync_service_1.evaluateCompletion)(source, target).done ||
+                target.receiveOnlyChangedFiles !== 0 ||
+                forceErrors(source).failed ||
+                targetErrors.failed) {
+                const reason = target.error ||
+                    source.error ||
+                    'The copies are not in sync or still have receive-only changes.';
+                problems.push(`${folder.id}: ${reason}`);
+            }
+        }
+        if (problems.length)
+            throw new error_types_1.AppError(`Force sync failed: ${[...problems, ...failedFiles].join('; ')}`, 'FORCE_SYNC_INCOMPLETE', 500);
+    }
     async final(run, projectId) {
         const { remoteId } = run.operation;
+        const owner = this.gitOwner.get(projectId);
         const ignores = this.syncIgnores(projectId);
         const devices = await this.pair(remoteId);
         const folders = await this.fileSync.projectFolders(projectId);
@@ -93,19 +445,31 @@ let FileSyncHandoff = class FileSyncHandoff {
                 ignores: folder.kind === 'code' ? ignores : (0, file_sync_dto_1.gitIgnores)(true),
                 paused: true,
             };
-            await this.host.syncFolders(remoteId, {
+            const ensureHost = () => this.host.syncFolders(remoteId, {
                 ...request,
-                type: folder.kind === 'code' ? 'sendreceive' : 'sendonly',
+                type: folder.kind === 'code' ? 'sendreceive' : owner === 'vm' ? 'sendonly' : 'receiveonly',
                 peerDeviceId: devices.home,
             });
-            await this.fileSync.ensureFolder({
+            const ensureHome = () => this.fileSync.ensureFolder({
                 ...request,
-                type: folder.kind === 'code' ? 'sendreceive' : 'receiveonly',
+                type: folder.kind === 'code' ? 'sendreceive' : owner === 'home' ? 'sendonly' : 'receiveonly',
                 peerDeviceId: devices.host,
             });
+            if (folder.kind === 'git' && owner === 'vm') {
+                await ensureHome();
+                await ensureHost();
+            }
+            else {
+                await ensureHost();
+                await ensureHome();
+            }
         }
         await this.unpauseAll(remoteId, folders);
-        await this.waitAll(run, folders, { sender: 'host', devices, symmetricCode: true });
+        await this.waitAll(run, folders, {
+            sender: (folder) => (folder.kind === 'git' && owner === 'home' ? 'home' : 'host'),
+            devices,
+            symmetricCode: true,
+        });
     }
     async flipToHome(run, projectId, force) {
         const { remoteId } = run.operation;
@@ -115,8 +479,25 @@ let FileSyncHandoff = class FileSyncHandoff {
             }
             await this.update('home', remoteId, folder.id, { type: 'sendonly', paused: true });
         }
+        if (force) {
+            await run.progress({
+                vmGuardSkipped: 'VM guard skipped: the forced Disconnect cannot reach the VM.',
+            });
+        }
+        else {
+            await run.progress({ vmGuardInstalled: true }, { durable: true });
+            const { warning } = await this.host.installGitGuard(remoteId, projectId, {
+                homeName: (0, node_os_1.hostname)(),
+                reason: 'disconnect',
+            });
+            await run.progress({ vmGuardWarning: warning, vmGuardInstalled: warning === null });
+        }
         await this.deleteHomeTempFiles(projectId);
-        await this.guard.remove(projectId, { refreshIndex: true });
+        const { warning } = await this.guard.remove(projectId, {
+            refreshIndex: this.gitOwner.get(projectId) === 'vm',
+        });
+        if (warning)
+            await run.progress({ guardWarning: warning });
     }
     async removeFolders(remoteId, projectId) {
         const folders = (0, file_sync_service_1.projectFolderList)(projectId);
@@ -136,23 +517,38 @@ let FileSyncHandoff = class FileSyncHandoff {
         }
     }
     async flipBackToHost(remoteId, projectId, force) {
+        const owner = this.gitOwner.get(projectId);
         const folders = await this.fileSync.projectFolders(projectId);
-        await this.hostDirections(remoteId, folders, force, false);
+        await this.hostDirections(remoteId, folders, owner, force, false);
         if (folders.some((folder) => folder.kind === 'git')) {
-            const guardWarning = await this.guard.reinstall(projectId, remoteId);
+            const guardWarning = owner === 'vm'
+                ? await this.guard.reinstall(projectId, remoteId)
+                : force
+                    ? null
+                    : (await this.host.installGitGuard(remoteId, projectId, {
+                        homeName: (0, node_os_1.hostname)(),
+                        reason: 'pc-git',
+                    })).warning;
             if (guardWarning) {
                 logger.warn({ projectId, remoteId, guardWarning }, 'Remote git guard not reinstalled');
             }
         }
     }
-    async hostDirections(remoteId, folders, force, paused) {
+    async hostDirections(remoteId, folders, owner, force, paused) {
         for (const folder of folders) {
             const pause = paused === undefined ? {} : { paused };
             if (folder.kind === 'git') {
                 const ignores = (0, file_sync_dto_1.gitIgnores)(true);
-                await this.update('home', remoteId, folder.id, { type: 'receiveonly', ignores, ...pause });
-                if (!force)
-                    await this.update('host', remoteId, folder.id, { type: 'sendonly', ignores, ...pause });
+                const receiver = owner === 'vm' ? 'home' : 'host';
+                const sender = owner === 'vm' ? 'host' : 'home';
+                if (receiver === 'home' || !force)
+                    await this.update(receiver, remoteId, folder.id, {
+                        type: 'receiveonly',
+                        ignores,
+                        ...pause,
+                    });
+                if (sender === 'home' || !force)
+                    await this.update(sender, remoteId, folder.id, { type: 'sendonly', ignores, ...pause });
             }
             else {
                 if (!force)
@@ -176,13 +572,14 @@ let FileSyncHandoff = class FileSyncHandoff {
             logger.warn({ projectId, error: error instanceof Error ? error.message : String(error) }, 'Syncthing temp-file cleanup skipped');
         }
     }
-    async pair(remoteId) {
+    async pair(remoteId, signal) {
         const home = this.fileSync.device();
         const host = await this.host.syncDevice(remoteId);
         await this.fileSync.addPeer(host);
         await this.host.syncPeer(remoteId, home);
         const deadline = Date.now() + CONNECT_TIMEOUT_MS;
         while (!(await this.fileSync.isConnected(host.deviceId))) {
+            signal?.throwIfAborted();
             if (Date.now() >= deadline)
                 throw new FileSyncNotConnectedError(host.address);
             await sleep(POLL_MS);
@@ -195,39 +592,77 @@ let FileSyncHandoff = class FileSyncHandoff {
             await this.update('home', remoteId, folder.id, { paused: false });
         }
     }
+    async waitHostIdle(remoteId, folderId, signal) {
+        const deadline = Date.now() + SYNC_TIMEOUT_MS;
+        for (;;) {
+            signal.throwIfAborted();
+            const status = await this.host.syncStatus(remoteId, folderId);
+            signal.throwIfAborted();
+            if (status.error || status.errors)
+                throw new file_sync_service_1.FileSyncTimeoutError(folderId, null, status.error ?? 'VM scan failed');
+            if (status.state === 'idle')
+                return;
+            if (Date.now() >= deadline)
+                throw new file_sync_service_1.FileSyncTimeoutError(folderId, null, 'The VM scan did not become idle.');
+            await sleep(POLL_MS);
+        }
+    }
     async waitAll(run, folders, options) {
         const { remoteId } = run.operation;
-        const receiver = options.sender === 'home' ? 'host' : 'home';
-        const receiverDevice = receiver === 'home' ? options.devices.home : options.devices.host;
         const progress = {};
         const report = () => run.progress({ fileSync: { folders: { ...progress } } });
         for (const folder of folders) {
             progress[folder.id] = { completion: 0, needItems: 0, needBytes: 0 };
         }
         await report();
-        await Promise.all(folders.map(async (folder) => {
-            const symmetric = options.symmetricCode === true && folder.kind === 'code';
-            await Promise.all([
-                this.scan(options.sender, remoteId, folder.id),
-                ...(symmetric ? [this.scan(receiver, remoteId, folder.id)] : []),
-            ]);
-            progress[folder.id] = await this.fileSync.waitForComplete(folder.id, {
-                symmetric,
-                sender: () => this.status(options.sender, remoteId, folder.id, receiverDevice),
-                receiver: async () => {
-                    const status = await this.status(receiver, remoteId, folder.id, symmetric ? options.devices[options.sender] : undefined);
-                    if (!symmetric && status.receiveOnlyChangedFiles > 0 && status.state === 'idle') {
-                        await this.revert(receiver, remoteId, folder.id);
-                    }
-                    return status;
-                },
-                timeoutMs: SYNC_TIMEOUT_MS,
-                onProgress: (current) => {
-                    progress[folder.id] = current;
-                    void report();
-                },
-            });
+        const stop = new AbortController();
+        const signal = options.signal ? AbortSignal.any([options.signal, stop.signal]) : stop.signal;
+        await Promise.allSettled(folders.map(async (folder) => {
+            try {
+                const sender = typeof options.sender === 'function' ? options.sender(folder) : options.sender;
+                const receiver = sender === 'home' ? 'host' : 'home';
+                const receiverDevice = options.devices[receiver];
+                const symmetric = options.symmetricCode === true && folder.kind === 'code';
+                await Promise.all([
+                    this.scan(sender, remoteId, folder.id, options.signal),
+                    ...(symmetric ? [this.scan(receiver, remoteId, folder.id)] : []),
+                ]);
+                progress[folder.id] = await this.fileSync.waitForComplete(folder.id, {
+                    symmetric,
+                    requireNoReceiveOnlyChanges: options.requireNoReceiveOnlyChanges,
+                    sender: () => this.status(sender, remoteId, folder.id, receiverDevice),
+                    receiver: async () => {
+                        const status = await this.status(receiver, remoteId, folder.id, symmetric ? options.devices[sender] : undefined);
+                        if (!symmetric && status.receiveOnlyChangedFiles > 0) {
+                            signal.throwIfAborted();
+                            const source = await this.status(sender, remoteId, folder.id, options.revertAfterComplete ? receiverDevice : undefined);
+                            signal.throwIfAborted();
+                            const transferred = (0, file_sync_service_1.senderIndexReached)(source, status) &&
+                                source.peer?.completion === 100 &&
+                                source.peer.needItems === 0 &&
+                                source.peer.remoteState === 'valid' &&
+                                status.needTotalItems === 0;
+                            if (options.revertAfterComplete ? transferred : (0, file_sync_service_1.senderIndexReached)(source, status))
+                                await this.revert(receiver, remoteId, folder.id);
+                        }
+                        return status;
+                    },
+                    timeoutMs: SYNC_TIMEOUT_MS,
+                    sides: { sender: SIDE_NAMES[sender], receiver: SIDE_NAMES[receiver] },
+                    onProgress: (current) => {
+                        progress[folder.id] = current;
+                        void report();
+                    },
+                    signal,
+                });
+            }
+            catch (error) {
+                stop.abort(error);
+                throw error;
+            }
         }));
+        if (stop.signal.aborted)
+            throw stop.signal.reason;
         await report();
     }
     async update(side, remoteId, folderId, patch) {
@@ -244,14 +679,18 @@ let FileSyncHandoff = class FileSyncHandoff {
             throw error;
         }
     }
-    status(side, remoteId, folderId, peerDeviceId) {
+    status(side, remoteId, folderId, peerDeviceId, options) {
+        if (options)
+            return side === 'home'
+                ? this.fileSync.status(folderId, peerDeviceId, options)
+                : this.host.syncStatus(remoteId, folderId, peerDeviceId, options);
         return side === 'home'
             ? this.fileSync.status(folderId, peerDeviceId)
             : this.host.syncStatus(remoteId, folderId, peerDeviceId);
     }
-    scan(side, remoteId, folderId) {
+    scan(side, remoteId, folderId, signal) {
         return side === 'home'
-            ? this.fileSync.rescan(folderId)
+            ? this.fileSync.rescan(folderId, signal)
             : this.host.syncScan(remoteId, folderId);
     }
     revert(side, remoteId, folderId) {
@@ -266,7 +705,9 @@ exports.FileSyncHandoff = FileSyncHandoff = __decorate([
     __metadata("design:paramtypes", [file_sync_service_1.FileSyncService,
         remote_host_client_1.RemoteHostClient,
         file_sync_managed_exclusions_store_1.FileSyncManagedExclusionsStore,
-        home_git_guard_service_1.HomeGitGuardService])
+        home_git_guard_service_1.HomeGitGuardService,
+        process_executor_port_1.ProcessExecutor,
+        git_owner_store_1.GitOwnerStore])
 ], FileSyncHandoff);
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));