devchain-cli 0.24.2 → 0.26.0

package/dist/server/modules/remotes/sync/remote-file-sync.service.d.ts

@@ -3,10 +3,11 @@ import { HomeGitGuardService } from '../../file-sync/home-git-guard.service';
 import { FileSyncManagedExclusionsStore } from '../../file-sync/file-sync-managed-exclusions.store';
 import { FileSyncAutoFixStore } from '../../file-sync/file-sync-auto-fix.store';
 import type { FileSyncAutoFix } from '../../file-sync/file-sync-auto-fix.dto';
-import { type SyncChownResult } from '../../file-sync/sync-chown.dto';
 import { FileSyncFailuresService } from './file-sync-failures.service';
+import { FileSyncSuggestionsService } from './file-sync-suggestions.service';
 import { FileSyncService } from '../../file-sync/file-sync.service';
 import { GitService } from '../../git/services/git.service';
+import type { GitCoordinatorRecord } from '../git-coordinator/git-coordinator.dto';
 import { type RemoteStorage, type ProjectStorage } from '../../storage/interfaces/storage.interface';
 import { RemoteHostClient } from '../operations/remote-host.client';
 import { type RemoteHealthPort } from '../ports/remote-health.port';
@@ -24,20 +25,18 @@ export declare class RemoteFileSyncService {
     private readonly autoFix;
     private readonly failures;
     private readonly gitOwner;
+    private readonly suggestions;
     private readonly projects;
-    constructor(files: FileSyncService, host: RemoteHostClient, bindings: RemoteBindingsService, health: RemoteHealthPort, exclusions: FileSyncManagedExclusionsStore, git: GitService, guard: HomeGitGuardService, storage: RemoteStorage & ProjectStorage, autoFix: FileSyncAutoFixStore, failures: FileSyncFailuresService, gitOwner: GitOwnerStore);
+    constructor(files: FileSyncService, host: RemoteHostClient, bindings: RemoteBindingsService, health: RemoteHealthPort, exclusions: FileSyncManagedExclusionsStore, git: GitService, guard: HomeGitGuardService, storage: RemoteStorage & ProjectStorage, autoFix: FileSyncAutoFixStore, failures: FileSyncFailuresService, gitOwner: GitOwnerStore, suggestions: FileSyncSuggestionsService);
     getIgnores(projectId: string): {
         ignores: string[];
         revision: number;
     };
     getAutoFix(projectId: string): FileSyncAutoFix;
     setAutoFix(projectId: string, enabled: boolean): FileSyncAutoFix;
-    ownershipNotes(projectId: string): string[];
-    giveOwnership(projectId: string, paths: string[], active: () => boolean): Promise<SyncChownResult>;
-    private recordRepairs;
     warning(projectId: string): string | null;
     problem(projectId: string): FileSyncProblem | null;
-    hasOpenHold(projectId: string): Promise<boolean>;
+    hasOpenHold(projectId: string, vm?: GitCoordinatorRecord): Promise<boolean>;
     assertNoHold(projectId: string): Promise<void>;
     forceSyncOffer(projectId: string, excludeOperationId?: string): Promise<ForceSyncOffer>;
     failedCounts(projectId: string): FileSyncFailedCounts | null;
@@ -46,9 +45,13 @@ export declare class RemoteFileSyncService {
     private retryPullErrors;
     private pauseCode;
     private resumeOwed;
+    private repairGitIgnores;
     tick(projectId: string, remoteId: string, active: () => boolean): Promise<void>;
+    private protectLaneBranches;
+    private followVmRecord;
     private checkSync;
     private fixAutomatically;
-    private repairAutomatically;
+    private scanVmOwnership;
+    private applyAutomaticExclusions;
     private move;
 }

package/dist/server/modules/remotes/sync/remote-file-sync.service.js

@@ -22,8 +22,8 @@ const home_git_guard_service_1 = require("../../file-sync/home-git-guard.service
 const file_sync_managed_exclusions_store_1 = require("../../file-sync/file-sync-managed-exclusions.store");
 const file_sync_auto_fix_store_1 = require("../../file-sync/file-sync-auto-fix.store");
 const sync_path_inspection_dto_1 = require("../../file-sync/sync-path-inspection.dto");
-const sync_chown_dto_1 = require("../../file-sync/sync-chown.dto");
 const file_sync_failures_service_1 = require("./file-sync-failures.service");
+const file_sync_suggestions_service_1 = require("./file-sync-suggestions.service");
 const file_sync_dto_1 = require("../../file-sync/file-sync.dto");
 const syncthing_rest_client_1 = require("../../file-sync/syncthing-rest.client");
 const file_sync_service_1 = require("../../file-sync/file-sync.service");
@@ -35,9 +35,9 @@ const remote_bindings_service_1 = require("../services/remote-bindings.service")
 const remote_file_sync_dto_1 = require("./remote-file-sync.dto");
 const logger = (0, logger_1.createLogger)('RemoteFileSyncService');
 const CHECK_INTERVAL_MS = 30_000;
+const OWNERSHIP_SCAN_INTERVAL_MS = 2 * 60_000;
 const PROBLEM_GRACE_MS = 2 * 60_000;
 const STALLED_MS = 10 * 60_000;
-const REPEAT_REPAIR_MS = 60 * 60_000;
 const MOVE_STEPS = ['create', 'settle', 'ignores', 'directions', 'guard', 'done'];
 const stepIndex = (step) => MOVE_STEPS.indexOf(step);
 let RemoteFileSyncService = class RemoteFileSyncService {
@@ -52,8 +52,9 @@ let RemoteFileSyncService = class RemoteFileSyncService {
     autoFix;
     failures;
     gitOwner;
+    suggestions;
     projects = new Map();
-    constructor(files, host, bindings, health, exclusions, git, guard, storage, autoFix, failures, gitOwner) {
+    constructor(files, host, bindings, health, exclusions, git, guard, storage, autoFix, failures, gitOwner, suggestions) {
         this.files = files;
         this.host = host;
         this.bindings = bindings;
@@ -65,6 +66,7 @@ let RemoteFileSyncService = class RemoteFileSyncService {
         this.autoFix = autoFix;
         this.failures = failures;
         this.gitOwner = gitOwner;
+        this.suggestions = suggestions;
     }
     getIgnores(projectId) {
         return {
@@ -78,60 +80,6 @@ let RemoteFileSyncService = class RemoteFileSyncService {
     setAutoFix(projectId, enabled) {
         return this.autoFix.setEnabled(projectId, enabled);
     }
-    ownershipNotes(projectId) {
-        const notes = this.projects.get(projectId)?.ownershipNotes;
-        if (!notes)
-            return [];
-        const now = Date.now();
-        for (const [path, at] of notes)
-            if (now - at >= REPEAT_REPAIR_MS)
-                notes.delete(path);
-        return [...notes.keys()].map((path) => `A container keeps writing as another user in ${path}.`);
-    }
-    async giveOwnership(projectId, paths, active) {
-        await this.assertNoHold(projectId);
-        const binding = await this.bindings.get(projectId);
-        if (binding?.state !== 'remote' || !active())
-            throw new error_types_1.ConflictError('The project must be connected to repair VM owners.');
-        const health = this.health.getState(binding.remoteId);
-        if (!health.online || health.apiKeyRejected || !health.versionMatches)
-            throw new error_types_1.ConflictError('The VM must be online with an accepted key and matching version.');
-        const failed = await this.failures.failed(projectId);
-        const eligible = new Set(failed.groups.filter(sync_path_inspection_dto_1.isGiveOwnershipEligible).map((group) => group.path));
-        const accepted = [...new Set(paths)].filter((path) => eligible.has(path));
-        const refused = paths
-            .filter((path) => !eligible.has(path))
-            .map((path) => ({
-            path,
-            state: 'refused',
-            paths: [],
-            reason: 'Give to requires a foreign-owned VM path Git neither tracks nor ignores.',
-        }));
-        if (!accepted.length)
-            return { user: failed.vmUser ?? null, items: refused };
-        await this.assertNoHold(projectId);
-        if (!active())
-            throw new error_types_1.ConflictError('The connection is changing.');
-        const { rootPath } = await this.storage.getProject(projectId);
-        const result = await this.host.syncChown(binding.remoteId, {
-            root: rootPath,
-            items: accepted.map((path) => ({ path, mode: 'give' })),
-        });
-        this.recordRepairs(projectId, result, Date.now());
-        if (result.items.some((item) => item.paths.length))
-            await this.retryPullErrors(projectId, 'vm', binding.remoteId, active);
-        return { ...result, items: [...result.items, ...refused] };
-    }
-    recordRepairs(projectId, result, now) {
-        const paths = [...new Set(result.items.flatMap((item) => item.paths))];
-        for (let offset = 0; offset < paths.length; offset += sync_chown_dto_1.SYNC_CHOWN_PATHS_MAX)
-            this.autoFix.record(projectId, {
-                at: new Date(now).toISOString(),
-                kind: 'chown',
-                side: 'vm',
-                paths: paths.slice(offset, offset + sync_chown_dto_1.SYNC_CHOWN_PATHS_MAX),
-            });
-    }
     warning(projectId) {
         const state = this.projects.get(projectId);
         return state?.checkWarning ?? state?.warning ?? state?.guardWarning ?? null;
@@ -144,19 +92,21 @@ let RemoteFileSyncService = class RemoteFileSyncService {
             return 'setup';
         return null;
     }
-    async hasOpenHold(projectId) {
+    async hasOpenHold(projectId, vm) {
+        if (vm && (vm.transition || vm.closed || Object.keys(vm.homeWrites).length))
+            return true;
         const operations = await this.storage.listRemoteOperations({
             projectId,
-            kinds: ['force_sync', 'git_owner'],
+            kinds: ['force_sync'],
             states: ['running', 'failed'],
             limit: 1,
         });
-        return operations.some((operation) => (operation.kind === 'force_sync' || operation.kind === 'git_owner') &&
+        return operations.some((operation) => operation.kind === 'force_sync' &&
             (operation.state === 'running' || operation.state === 'failed'));
     }
     async assertNoHold(projectId) {
         if (await this.hasOpenHold(projectId))
-            throw new error_types_1.ConflictError('Force sync or a Git switch is running for this project. Save the list after it finishes.');
+            throw new error_types_1.ConflictError('Force sync is running for this project. Save the list after it finishes.');
     }
     async forceSyncOffer(projectId, excludeOperationId) {
         const pending = { fromVm: null, fromHome: null };
@@ -335,6 +285,18 @@ let RemoteFileSyncService = class RemoteFileSyncService {
             }
         }
     }
+    async repairGitIgnores(projectId, remoteId) {
+        const id = (0, file_sync_service_1.projectFolderId)(projectId, 'git');
+        const ignores = (0, file_sync_dto_1.gitIgnores)(true);
+        const [home, vm] = await Promise.all([
+            this.files.installedIgnores(id),
+            this.host.syncFolderIgnores(remoteId, id),
+        ]);
+        if (home.ignore.join('\0') !== ignores.join('\0'))
+            await this.files.updateFolder(id, { ignores });
+        if (vm.ignore.join('\0') !== ignores.join('\0'))
+            await this.host.syncFolderType(remoteId, id, { ignores }, this.gitOwner.fence(projectId));
+    }
     async tick(projectId, remoteId, active) {
         const health = this.health.getState(remoteId);
         if (!active() || !health.online || health.apiKeyRejected || !health.versionMatches)
@@ -358,54 +320,59 @@ let RemoteFileSyncService = class RemoteFileSyncService {
                 await this.move(projectId, state, active);
                 return;
             }
+            const now = Date.now();
+            if (state.hasGit &&
+                (state.ignoresRepairedAt === undefined ||
+                    now - state.ignoresRepairedAt >= CHECK_INTERVAL_MS)) {
+                await this.repairGitIgnores(projectId, remoteId);
+                state.ignoresRepairedAt = now;
+            }
+            if (!active())
+                return;
             await this.checkSync(projectId, state, active);
             if (!state.hasGit || !active())
                 return;
-            const owner = this.gitOwner.get(projectId);
-            const receiver = owner === 'vm' ? 'home' : 'vm';
-            const generation = this.gitOwner.generation(projectId);
-            if (state.headsGeneration !== generation) {
-                state.heads = undefined;
-                state.headsGeneration = generation;
+            const vm = await this.host.gitCoordinatorStatus(remoteId, projectId);
+            if (!active() || (await this.hasOpenHold(projectId, vm)))
+                return;
+            const owner = this.followVmRecord(projectId, vm, state);
+            if (owner === null || !active())
+                return;
+            if (owner === 'home') {
+                await this.protectLaneBranches(projectId, remoteId, state, vm.worktreeBranches);
+                if (!active())
+                    return;
             }
             const id = (0, file_sync_service_1.projectFolderId)(projectId, 'git');
-            const config = receiver === 'home'
+            const config = owner === 'vm'
                 ? await this.files.folderConfiguration(id)
                 : await this.host.syncFolderConfiguration(remoteId, id);
             if (!active() || config.type !== 'receiveonly' || config.paused)
                 return;
-            const status = receiver === 'home'
-                ? await this.files.status(id)
-                : await this.host.syncStatus(remoteId, id);
+            const status = owner === 'vm' ? await this.files.status(id) : await this.host.syncStatus(remoteId, id);
             if (!active() || status.state !== 'idle' || status.needTotalItems !== 0)
                 return;
             state.warning = null;
             if (status.receiveOnlyChangedFiles > 0) {
-                if (receiver === 'home')
+                if (owner === 'vm')
                     await this.files.revertLocalChanges(id);
                 else
-                    await this.host.syncRevert(remoteId, id);
+                    await this.host.syncRevert(remoteId, id, this.gitOwner.fence(projectId));
+                return;
+            }
+            if (owner === 'home')
                 return;
+            const revision = this.gitOwner.revision(projectId);
+            if (state.homeHeadRevision !== revision) {
+                state.homeHead = undefined;
+                state.homeHeadRevision = revision;
             }
             const root = await this.files.folderPath(projectId);
             const head = await this.git.mirroredHead(projectId, root);
-            if (!active() || head === null || head === state.heads?.[receiver])
+            if (!active() || head === null || head === state.homeHead)
                 return;
-            if (receiver === 'home') {
-                await this.git.refreshIndexFromHead(projectId, root);
-                (state.heads ??= {}).home = head;
-            }
-            else {
-                const result = await this.host.refreshGitIndex(remoteId, projectId, state.heads?.vm ?? null);
-                if (!active())
-                    return;
-                if (result.warning) {
-                    state.warning = result.warning;
-                    return;
-                }
-                if (result.refreshed && result.head !== null)
-                    (state.heads ??= {}).vm = result.head;
-            }
+            await this.git.refreshIndexFromHead(projectId, root);
+            state.homeHead = head;
         }
         catch (error) {
             state.warning =
@@ -413,6 +380,32 @@ let RemoteFileSyncService = class RemoteFileSyncService {
             logger.warn({ error, projectId, step: state.step }, 'Remote file sync will retry');
         }
     }
+    async protectLaneBranches(projectId, remoteId, state, worktreeBranches) {
+        try {
+            const warning = await this.guard.protectBranches(projectId, remoteId, worktreeBranches);
+            if (warning && warning !== state.laneBranchesWarning)
+                logger.warn({ projectId }, warning);
+            state.laneBranchesWarning = warning;
+        }
+        catch (error) {
+            logger.warn({ error, projectId }, 'VM worktree branch protection was not refreshed');
+        }
+    }
+    followVmRecord(projectId, vm, state) {
+        const cached = this.gitOwner.get(projectId);
+        if (vm.generation === this.gitOwner.generation(projectId) &&
+            (vm.owner === cached || cached === 'home'))
+            return cached;
+        if (vm.owner === 'vm' && cached === 'vm') {
+            this.gitOwner.remember(projectId, vm);
+            return 'vm';
+        }
+        state.warning =
+            cached === 'home'
+                ? 'The VM took Git back while this PC was away. File sync continues after this PC gives up Git.'
+                : 'Git is moving to this PC. File sync continues after the move finishes.';
+        return null;
+    }
     async checkSync(projectId, state, active) {
         const now = Date.now();
         if (!active() || (state.lastCheck !== undefined && now - state.lastCheck < CHECK_INTERVAL_MS))
@@ -490,6 +483,8 @@ let RemoteFileSyncService = class RemoteFileSyncService {
                 state.autoFixAttempt = undefined;
             if (state.failed && active())
                 await this.fixAutomatically(projectId, state, { home: homeCount, vm: vmCount }, now, active);
+            if (vmStatus?.sequence !== undefined && active())
+                await this.scanVmOwnership(projectId, state, vmStatus.sequence, now, active);
         }
         catch (error) {
             if (!active())
@@ -514,85 +509,74 @@ let RemoteFileSyncService = class RemoteFileSyncService {
             const failed = await this.failures.failed(projectId);
             if (!active() || !this.autoFix.get(projectId).enabled)
                 return;
-            await this.repairAutomatically(projectId, state, failed, now, active);
-            if (!active() || !this.autoFix.get(projectId).enabled)
-                return;
-            const groups = failed.groups.filter((group) => (0, sync_path_inspection_dto_1.isSelectableExclusion)(group) &&
-                group.selected &&
-                group.reasonKind === 'foreignOwner' &&
-                !group.home?.tracked &&
-                !group.vm?.tracked &&
-                group.patternChecksPassed === true);
-            const current = this.files.getIgnores(projectId);
-            const additions = groups
-                .flatMap((group) => group.patterns)
-                .filter((pattern) => !current.includes(pattern));
-            const list = [...new Set([...current, ...additions])];
-            if (additions.length === 0 || !file_sync_dto_1.IgnorePatternsSchema.safeParse(list).success)
-                return;
-            if (await this.hasOpenHold(projectId))
-                return;
-            if (!active())
-                return;
-            await this.saveIgnores(projectId, list, active, revision);
-            for (const side of ['home', 'vm']) {
-                const patterns = [
-                    ...new Set(groups
-                        .filter((group) => group.side === side)
-                        .flatMap((group) => group.patterns)
-                        .filter((pattern) => additions.includes(pattern))),
-                ];
-                if (patterns.length)
-                    this.autoFix.record(projectId, {
-                        at: new Date(now).toISOString(),
-                        kind: 'exclude',
-                        side,
-                        patterns,
-                    });
-            }
+            await this.applyAutomaticExclusions(projectId, failed.groups, revision, now, active);
         }
         catch (error) {
             logger.warn({ error, projectId }, 'Automatic file sync exclusions will retry');
         }
     }
-    async repairAutomatically(projectId, state, failed, now, active) {
-        const attempts = (state.repairAttempts ??= new Map());
-        const paths = (failed.vm?.entries ?? [])
-            .filter((entry) => entry.git?.state === 'repo' &&
-            entry.git.tracked === true &&
-            failed.groups.some((group) => group.chown && (0, sync_path_inspection_dto_1.within)(entry.path, group.path)) &&
-            now - (attempts.get(entry.path) ?? -Infinity) >= STALLED_MS)
-            .map((entry) => entry.path);
-        if (!paths.length || (await this.hasOpenHold(projectId)) || !active())
+    async scanVmOwnership(projectId, state, sequence, now, active) {
+        if (!this.autoFix.get(projectId).enabled)
             return;
-        const { rootPath } = await this.storage.getProject(projectId);
+        const previous = state.ownershipScan;
+        if (previous &&
+            (sequence === previous.inspectedSequence ||
+                now - previous.attemptedAt < OWNERSHIP_SCAN_INTERVAL_MS))
+            return;
+        const scan = { ...previous, attemptedAt: now };
+        state.ownershipScan = scan;
         try {
+            const revision = this.files.getIgnoresRevision(projectId);
+            const result = await this.suggestions.vmSuggestions(projectId, state.remoteId);
             if (!active() || !this.autoFix.get(projectId).enabled)
                 return;
-            for (const path of paths)
-                attempts.set(path, now);
-            const result = await this.host.syncChown(state.remoteId, {
-                root: rootPath,
-                items: paths.map((path) => ({ path, mode: 'automatic' })),
-            });
-            this.recordRepairs(projectId, result, now);
-            const repaired = (state.repairedAt ??= new Map());
-            for (const item of result.items.filter((item) => item.paths.length > 0)) {
-                const previous = repaired.get(item.path);
-                if (previous !== undefined && now - previous < REPEAT_REPAIR_MS)
-                    (state.ownershipNotes ??= new Map()).set(item.path, now);
-                repaired.set(item.path, now);
-            }
-            if (result.items.some((item) => item.paths.length))
-                await this.retryPullErrors(projectId, 'vm', state.remoteId, active);
+            if (await this.applyAutomaticExclusions(projectId, result.groups, revision, now, active, 'vm'))
+                scan.inspectedSequence = sequence;
         }
         catch (error) {
-            logger.warn({ error, projectId }, 'Automatic VM ownership repair will retry');
+            logger.warn({ error, projectId }, 'VM ownership exclusions will retry');
+        }
+    }
+    async applyAutomaticExclusions(projectId, suggestions, revision, now, active, sourceSide) {
+        const groups = suggestions.filter((group) => (0, sync_path_inspection_dto_1.isSelectableExclusion)(group) &&
+            group.selected &&
+            group.reasonKind === 'foreignOwner' &&
+            !group.home?.tracked &&
+            !group.vm?.tracked &&
+            group.patternChecksPassed === true);
+        const current = this.files.getIgnores(projectId);
+        const additions = groups
+            .flatMap((group) => group.patterns)
+            .filter((pattern) => !current.includes(pattern));
+        const list = [...new Set([...current, ...additions])];
+        if (additions.length === 0)
+            return true;
+        if (!file_sync_dto_1.IgnorePatternsSchema.safeParse(list).success)
+            return false;
+        if (await this.hasOpenHold(projectId))
+            return false;
+        if (!active())
+            return false;
+        const saved = await this.saveIgnores(projectId, list, active, revision);
+        for (const side of ['home', 'vm']) {
+            const patterns = [
+                ...new Set(groups
+                    .filter((group) => (sourceSide ?? group.side) === side)
+                    .flatMap((group) => group.patterns)
+                    .filter((pattern) => additions.includes(pattern))),
+            ];
+            if (patterns.length)
+                this.autoFix.record(projectId, {
+                    at: new Date(now).toISOString(),
+                    kind: 'exclude',
+                    side,
+                    patterns,
+                });
         }
+        return saved.applied;
     }
     async move(projectId, state, active) {
         const { remoteId } = state;
-        const owner = this.gitOwner.get(projectId);
         const codeId = (0, file_sync_service_1.projectFolderId)(projectId, 'code');
         const gitId = (0, file_sync_service_1.projectFolderId)(projectId, 'git');
         if (state.step === 'create') {
@@ -600,6 +584,19 @@ let RemoteFileSyncService = class RemoteFileSyncService {
             if (!active() || !folders.some((folder) => folder.kind === 'code'))
                 return;
             state.hasGit = (await this.files.initialFolders(projectId)).some((folder) => folder.kind === 'git');
+        }
+        let owner = this.gitOwner.get(projectId);
+        if (state.hasGit) {
+            const vm = await this.host.gitCoordinatorStatus(remoteId, projectId);
+            if (!active() || (await this.hasOpenHold(projectId, vm)))
+                return;
+            const followed = this.followVmRecord(projectId, vm, state);
+            if (followed === null)
+                return;
+            owner = followed;
+        }
+        const fence = this.gitOwner.fence(projectId);
+        if (state.step === 'create') {
             if (state.hasGit) {
                 const home = this.files.device();
                 const host = await this.host.syncDevice(remoteId);
@@ -614,7 +611,7 @@ let RemoteFileSyncService = class RemoteFileSyncService {
                     peerDeviceId: home.deviceId,
                     ignores: (0, file_sync_dto_1.gitIgnores)(true),
                     paused: true,
-                });
+                }, fence);
                 const ensureHome = () => this.files.ensureFolder({
                     projectId,
                     kind: 'git',
@@ -631,9 +628,9 @@ let RemoteFileSyncService = class RemoteFileSyncService {
                     await ensureVm();
                     await ensureHome();
                 }
-                await this.host.syncFolderType(remoteId, gitId, { paused: false });
+                await this.host.syncFolderType(remoteId, gitId, { paused: false }, fence);
                 await this.files.updateFolder(gitId, { paused: false });
-                await Promise.all([this.host.syncScan(remoteId, gitId), this.files.rescan(gitId)]);
+                await Promise.all([this.host.syncScan(remoteId, gitId, fence), this.files.rescan(gitId)]);
             }
             state.step = state.hasGit ? 'settle' : 'ignores';
         }
@@ -660,7 +657,7 @@ let RemoteFileSyncService = class RemoteFileSyncService {
                 if (owner === 'vm')
                     await this.files.revertLocalChanges(gitId);
                 else
-                    await this.host.syncRevert(remoteId, gitId);
+                    await this.host.syncRevert(remoteId, gitId, fence);
                 return;
             }
             if (!(0, file_sync_service_1.evaluateCompletion)(sender, receiver).done) {
@@ -692,10 +689,7 @@ let RemoteFileSyncService = class RemoteFileSyncService {
                 state.guardWarning =
                     owner === 'vm'
                         ? await this.guard.install(projectId, remoteId)
-                        : (await this.host.installGitGuard(remoteId, projectId, {
-                            homeName: (0, node_os_1.hostname)(),
-                            reason: 'pc-git',
-                        })).warning;
+                        : (await this.host.installGitGuard(remoteId, projectId, { homeName: (0, node_os_1.hostname)(), reason: 'pc-git' }, fence)).warning;
             }
             state.step = 'done';
             state.warning = null;
@@ -713,7 +707,8 @@ exports.RemoteFileSyncService = RemoteFileSyncService = __decorate([
         git_service_1.GitService,
         home_git_guard_service_1.HomeGitGuardService, Object, file_sync_auto_fix_store_1.FileSyncAutoFixStore,
         file_sync_failures_service_1.FileSyncFailuresService,
-        git_owner_store_1.GitOwnerStore])
+        git_owner_store_1.GitOwnerStore,
+        file_sync_suggestions_service_1.FileSyncSuggestionsService])
 ], RemoteFileSyncService);
 function folderError(config, status, includeFailedFiles = true) {
     if (config.paused)