devchain-cli 0.24.1 → 0.24.2

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

@@ -14,19 +14,32 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteFileSyncService = void 0;
 const common_1 = require("@nestjs/common");
+const node_os_1 = require("node:os");
+const git_owner_store_1 = require("../git-owner.store");
 const logger_1 = require("../../../common/logging/logger");
+const error_types_1 = require("../../../common/errors/error-types");
 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_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");
 const git_service_1 = require("../../git/services/git.service");
+const storage_interface_1 = require("../../storage/interfaces/storage.interface");
 const remote_host_client_1 = require("../operations/remote-host.client");
 const remote_health_port_1 = require("../ports/remote-health.port");
 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 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 {
     files;
     host;
@@ -35,8 +48,12 @@ let RemoteFileSyncService = class RemoteFileSyncService {
     exclusions;
     git;
     guard;
+    storage;
+    autoFix;
+    failures;
+    gitOwner;
     projects = new Map();
-    constructor(files, host, bindings, health, exclusions, git, guard) {
+    constructor(files, host, bindings, health, exclusions, git, guard, storage, autoFix, failures, gitOwner) {
         this.files = files;
         this.host = host;
         this.bindings = bindings;
@@ -44,18 +61,286 @@ let RemoteFileSyncService = class RemoteFileSyncService {
         this.exclusions = exclusions;
         this.git = git;
         this.guard = guard;
+        this.storage = storage;
+        this.autoFix = autoFix;
+        this.failures = failures;
+        this.gitOwner = gitOwner;
+    }
+    getIgnores(projectId) {
+        return {
+            ignores: this.files.getIgnores(projectId),
+            revision: this.files.getIgnoresRevision(projectId),
+        };
+    }
+    getAutoFix(projectId) {
+        return this.autoFix.get(projectId);
+    }
+    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;
     }
+    problem(projectId) {
+        const state = this.projects.get(projectId);
+        if (state?.checkWarning)
+            return state.checkProblem ?? null;
+        if (state?.warning)
+            return 'setup';
+        return null;
+    }
+    async hasOpenHold(projectId) {
+        const operations = await this.storage.listRemoteOperations({
+            projectId,
+            kinds: ['force_sync', 'git_owner'],
+            states: ['running', 'failed'],
+            limit: 1,
+        });
+        return operations.some((operation) => (operation.kind === 'force_sync' || operation.kind === 'git_owner') &&
+            (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.');
+    }
+    async forceSyncOffer(projectId, excludeOperationId) {
+        const pending = { fromVm: null, fromHome: null };
+        const refuse = (reason) => ({ offered: false, reason, pending });
+        const binding = await this.bindings.get(projectId);
+        if (binding?.state !== 'remote')
+            return refuse('The project must be connected to Force sync.');
+        const device = await this.host.syncDevice(binding.remoteId).catch(() => null);
+        const ids = ['code', 'git'].map((kind) => (0, file_sync_service_1.projectFolderId)(projectId, kind));
+        const reads = await Promise.allSettled([
+            ...ids.map((id, index) => this.files.status(id, index === 0 ? device?.deviceId : undefined, { allErrors: true })),
+            ...ids.map((id) => this.host.syncStatus(binding.remoteId, id, undefined, { allErrors: true })),
+        ]);
+        const homeCode = reads[0];
+        if (homeCode.status === 'fulfilled') {
+            pending.fromVm = homeCode.value.needTotalItems ?? null;
+            pending.fromHome = homeCode.value.peer?.needItems ?? null;
+        }
+        const errors = [];
+        for (const [index, read] of reads.entries()) {
+            if (read.status === 'rejected') {
+                const error = read.reason;
+                if ((error instanceof syncthing_rest_client_1.SyncthingRestError || error instanceof remote_host_client_1.RemoteHostRequestError) &&
+                    error.status === 404)
+                    continue;
+                return refuse(index < 2
+                    ? "DevChain could not read this PC's file sync status."
+                    : "DevChain could not read the VM's file sync status.");
+            }
+            const status = read.value;
+            errors.push(...(status.fileErrors ?? []).map((entry) => entry.error));
+            if (status.error)
+                errors.push(status.error);
+        }
+        const persistent = errors.filter((error) => !(0, file_sync_dto_1.isTransientSyncError)(error));
+        if (persistent.some((error) => /permission denied|operation not permitted/i.test(error)))
+            return refuse('Repair file permissions before using Force sync.');
+        const health = this.health.getState(binding.remoteId);
+        if (health.apiKeyRejected)
+            return refuse("The VM rejected this PC's API key.");
+        if (!health.online)
+            return refuse('The VM is offline.');
+        if (!health.versionMatches)
+            return refuse('The VM runs a different DevChain version.');
+        if (!device)
+            return refuse("DevChain could not read the VM's file sync status.");
+        const connected = await this.files.isConnected(device.deviceId).catch(() => false);
+        if (!connected)
+            return refuse('There is no file sync connection to the VM.');
+        const operations = await this.storage.listRemoteOperations({
+            projectId,
+            states: ['running', 'failed'],
+        });
+        if (operations.some((operation) => operation.id !== excludeOperationId))
+            return refuse('Another operation is open for this project.');
+        const problem = this.problem(projectId);
+        const failedFiles = reads.some((read) => read.status === 'fulfilled' &&
+            (read.value.fileErrors ?? []).some((entry) => !(0, file_sync_dto_1.isTransientSyncError)(entry.error)));
+        if (!(0, remote_file_sync_dto_1.isStuckFileSyncProblem)(problem) && !failedFiles)
+            return refuse('File sync has no stuck problem to repair.');
+        return { offered: true, reason: null, pending };
+    }
+    failedCounts(projectId) {
+        return this.projects.get(projectId)?.failed ?? null;
+    }
     forget(projectId) {
         this.projects.delete(projectId);
     }
+    async saveIgnores(projectId, list, active, expectedRevision) {
+        const ignores = this.files.setIgnores(projectId, list, expectedRevision);
+        const revision = this.files.getIgnoresRevision(projectId);
+        const notApplied = (reason) => ({
+            ignores,
+            revision,
+            applied: false,
+            message: `Saved, not applied yet: ${reason}; DevChain applies it automatically while the project stays connected.`,
+        });
+        const deferred = (reason) => {
+            const state = this.projects.get(projectId);
+            if (state && stepIndex(state.step) > stepIndex('ignores'))
+                state.step = 'ignores';
+            return notApplied(reason);
+        };
+        let reason = 'the connection could not be checked';
+        try {
+            const binding = await this.bindings.get(projectId);
+            if (binding?.state === 'attaching')
+                return notApplied('the project is connecting');
+            if (binding?.state !== 'remote') {
+                return {
+                    ignores,
+                    revision,
+                    applied: false,
+                    message: 'Saved. The list applies at the next Connect.',
+                };
+            }
+            if (!active())
+                return deferred('live sync is not running');
+            const health = this.health.getState(binding.remoteId);
+            if (health.apiKeyRejected)
+                return deferred("the VM rejected this PC's API key");
+            if (!health.online)
+                return deferred('the VM is offline');
+            if (!health.versionMatches)
+                return deferred('the VM runs a different DevChain version');
+            const state = this.projects.get(projectId);
+            if (!state ||
+                state.remoteId !== binding.remoteId ||
+                stepIndex(state.step) < stepIndex('ignores')) {
+                return deferred('file sync setup is still running');
+            }
+            reason = 'the ignore list could not be prepared';
+            const installed = (0, file_sync_dto_1.codeIgnores)(this.exclusions.get(projectId), ignores);
+            const codeId = (0, file_sync_service_1.projectFolderId)(projectId, 'code');
+            reason = 'the VM could not apply the list';
+            await this.host.syncFolderType(binding.remoteId, codeId, { ignores: installed });
+            await this.retryPullErrors(projectId, 'vm', binding.remoteId, active);
+            if (!active())
+                return deferred('the connection is changing');
+            reason = 'this PC could not apply the list';
+            try {
+                await this.files.updateFolder(codeId, { ignores: installed });
+                await this.retryPullErrors(projectId, 'home', binding.remoteId, active);
+            }
+            catch (error) {
+                if (error instanceof syncthing_rest_client_1.SyncthingRestError && error.status === 404)
+                    reason = 'the folder is not shared on this PC';
+                throw error;
+            }
+            return { ignores, revision, applied: true, message: 'Applied to the VM and this PC.' };
+        }
+        catch (error) {
+            logger.warn({ error, projectId }, 'Saved file sync ignores will retry');
+            return deferred(reason);
+        }
+    }
+    async retryPullErrors(projectId, side, remoteId, active) {
+        const codeId = (0, file_sync_service_1.projectFolderId)(projectId, 'code');
+        try {
+            if (!active())
+                return;
+            const status = side === 'vm'
+                ? await this.host.syncStatus(remoteId, codeId)
+                : await this.files.status(codeId);
+            if (!active() || (status.pullErrors ?? 0) <= 0)
+                return;
+            const state = this.projects.get(projectId);
+            if (state)
+                (state.resume ??= new Set()).add(side);
+            try {
+                await this.pauseCode(codeId, side, remoteId, true);
+            }
+            finally {
+                await this.pauseCode(codeId, side, remoteId, false);
+                state?.resume?.delete(side);
+            }
+        }
+        catch (error) {
+            logger.warn({ error, projectId, side }, 'File sync folder restart failed after applying ignores');
+        }
+    }
+    pauseCode(codeId, side, remoteId, paused) {
+        return side === 'vm'
+            ? this.host.syncFolderType(remoteId, codeId, { paused })
+            : this.files.updateFolder(codeId, { paused });
+    }
+    async resumeOwed(projectId, state) {
+        const codeId = (0, file_sync_service_1.projectFolderId)(projectId, 'code');
+        for (const side of [...(state.resume ?? [])]) {
+            try {
+                await this.pauseCode(codeId, side, state.remoteId, false);
+                state.resume.delete(side);
+            }
+            catch (error) {
+                logger.warn({ error, projectId, side }, 'File sync folder resume will retry');
+            }
+        }
+    }
     async tick(projectId, remoteId, active) {
         const health = this.health.getState(remoteId);
         if (!active() || !health.online || health.apiKeyRejected || !health.versionMatches)
             return;
+        if (await this.hasOpenHold(projectId))
+            return;
         const binding = await this.bindings.get(projectId);
         if (!active() || binding?.state !== 'remote' || binding.remoteId !== remoteId)
             return;
@@ -65,6 +350,10 @@ let RemoteFileSyncService = class RemoteFileSyncService {
             this.projects.set(projectId, state);
         }
         try {
+            if (state.resume?.size)
+                await this.resumeOwed(projectId, state);
+            if (!active())
+                return;
             if (state.step !== 'done') {
                 await this.move(projectId, state, active);
                 return;
@@ -72,24 +361,51 @@ let RemoteFileSyncService = class RemoteFileSyncService {
             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 id = (0, file_sync_service_1.projectFolderId)(projectId, 'git');
-            const config = await this.files.folderConfiguration(id);
+            const config = receiver === 'home'
+                ? await this.files.folderConfiguration(id)
+                : await this.host.syncFolderConfiguration(remoteId, id);
             if (!active() || config.type !== 'receiveonly' || config.paused)
                 return;
-            const status = await this.files.status(id);
+            const status = receiver === 'home'
+                ? 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) {
-                await this.files.revertLocalChanges(id);
+                if (receiver === 'home')
+                    await this.files.revertLocalChanges(id);
+                else
+                    await this.host.syncRevert(remoteId, id);
                 return;
             }
             const root = await this.files.folderPath(projectId);
             const head = await this.git.mirroredHead(projectId, root);
-            if (!active() || head === null || head === state.head)
+            if (!active() || head === null || head === state.heads?.[receiver])
                 return;
-            await this.git.refreshIndexFromHead(projectId, root);
-            state.head = head;
+            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;
+            }
         }
         catch (error) {
             state.warning =
@@ -111,54 +427,172 @@ let RemoteFileSyncService = class RemoteFileSyncService {
             const code = configurations.find((folder) => folder.kind === 'code');
             const homeId = this.files.device().deviceId;
             const peers = code?.config.devices.filter((device) => device.deviceID !== homeId);
-            if (peers?.length !== 1)
+            if (!code || peers?.length !== 1)
                 throw new Error('Expected one VM device in the code folder');
             const peerId = peers[0].deviceID;
-            const [connected, statuses] = await Promise.all([
+            const [connected, statuses, vmStatus] = await Promise.all([
                 this.files.isConnected(peerId),
                 Promise.all(configurations.map(async (folder) => ({
                     ...folder,
                     status: await this.files.status(folder.id, folder.kind === 'code' ? peerId : undefined),
                 }))),
+                this.host.syncStatus(state.remoteId, code.id).catch((error) => {
+                    logger.warn({ error, projectId }, 'VM file sync status could not be read');
+                    return null;
+                }),
             ]);
             if (!active())
                 return;
             const observations = new Map();
             const warnings = [];
-            const observe = (key, count, limit, message) => {
+            const observe = (key, count, limit, message, problem, bytes) => {
                 if (count <= 0)
-                    return;
+                    return 0;
                 const previous = state.observations?.get(key);
-                const since = !previous || count < previous.count ? now : previous.since;
-                observations.set(key, { since, count });
-                if (now - since >= limit)
-                    warnings.push(message(new Date(since).toTimeString().slice(0, 5)));
+                const since = !previous ||
+                    count < previous.count ||
+                    (bytes !== undefined && previous.bytes !== undefined && bytes < previous.bytes)
+                    ? now
+                    : previous.since;
+                observations.set(key, { since, count, bytes });
+                if (now - since < limit)
+                    return 0;
+                warnings.push({ message: message(new Date(since).toTimeString().slice(0, 5)), problem });
+                return count;
             };
-            observe('connection', connected ? 0 : 1, PROBLEM_GRACE_MS, (since) => `No file sync connection to the VM since ${since}; changes do not move between this PC and the VM.`);
-            for (const { id, config, status } of statuses) {
-                const error = folderError(config, status);
-                observe(`error:${id}`, error ? 1 : 0, PROBLEM_GRACE_MS, (since) => `File sync at home has an error since ${since}: ${error}.`);
+            observe('connection', connected ? 0 : 1, PROBLEM_GRACE_MS, (since) => `No file sync connection to the VM since ${since}; changes do not move between this PC and the VM.`, 'connection');
+            const homeCode = statuses.find((folder) => folder.kind === 'code');
+            const vmCount = vmStatus
+                ? (vmStatus.errors ?? 0)
+                : (state.observations?.get('vm-failed')?.count ?? 0);
+            const vmFailed = observe('vm-failed', vmCount, PROBLEM_GRACE_MS, (since) => `${vmCount} files on the VM fail to sync since ${since}.`, 'failed-files');
+            const homeCount = homeCode.status.errors ?? 0;
+            const homeFailed = observe('home-failed', homeCount, PROBLEM_GRACE_MS, (since) => `${homeCount} files on this PC fail to sync since ${since}.`, 'failed-files');
+            for (const { id, kind, config, status } of statuses) {
+                const error = folderError(config, status, kind !== 'code');
+                observe(`error:${id}`, error ? 1 : 0, PROBLEM_GRACE_MS, (since) => `File sync at home has an error since ${since}: ${error}.`, !config.paused && !status.error?.trim() && (status.errors ?? 0) > 0
+                    ? 'failed-files'
+                    : 'error');
             }
             const stalled = `no progress for ${STALLED_MS / 60_000} minutes`;
             for (const { id, status } of statuses) {
-                observe(`home:${id}`, status.needTotalItems, STALLED_MS, (since) => `This PC has not received ${status.needTotalItems} pending file sync items since ${since} (${stalled}).`);
+                observe(`home:${id}`, status.needTotalItems, STALLED_MS, (since) => `This PC has not received ${status.needTotalItems} pending file sync items since ${since} (${stalled}).`, 'stalled', status.needBytes);
                 const { peer } = status;
                 if (peer) {
-                    observe(`peer:${id}`, peer.needItems, STALLED_MS, (since) => `The VM has not received ${peer.needItems} pending file sync items from this PC since ${since} (${stalled}).`);
+                    observe(`peer:${id}`, peer.needItems, STALLED_MS, (since) => `The VM has not received ${peer.needItems} pending file sync items from this PC since ${since} (${stalled}).`, 'stalled', peer.needBytes);
                 }
             }
             state.observations = observations;
-            state.checkWarning = warnings[0] ?? null;
+            state.checkWarning = warnings[0]?.message ?? null;
+            state.checkProblem = warnings[0]?.problem;
+            state.failed = homeFailed || vmFailed ? { home: homeFailed, vm: vmFailed } : undefined;
+            if (homeCount === 0 && vmCount === 0)
+                state.autoFixAttempt = undefined;
+            if (state.failed && active())
+                await this.fixAutomatically(projectId, state, { home: homeCount, vm: vmCount }, now, active);
         }
         catch (error) {
             if (!active())
                 return;
+            state.checkProblem = 'error';
             state.checkWarning = 'DevChain could not read the file sync status. It will try again.';
             logger.warn({ error, projectId }, 'Remote file sync check failed');
         }
     }
+    async fixAutomatically(projectId, state, counts, now, active) {
+        if (!this.autoFix.get(projectId).enabled)
+            return;
+        const previous = state.autoFixAttempt;
+        if (previous &&
+            previous.home === counts.home &&
+            previous.vm === counts.vm &&
+            now - previous.at < STALLED_MS)
+            return;
+        state.autoFixAttempt = { ...counts, at: now };
+        try {
+            const revision = this.files.getIgnoresRevision(projectId);
+            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,
+                    });
+            }
+        }
+        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())
+            return;
+        const { rootPath } = await this.storage.getProject(projectId);
+        try {
+            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);
+        }
+        catch (error) {
+            logger.warn({ error, projectId }, 'Automatic VM ownership repair will retry');
+        }
+    }
     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') {
@@ -173,22 +607,30 @@ let RemoteFileSyncService = class RemoteFileSyncService {
                     return;
                 await this.files.addPeer(host);
                 await this.host.syncPeer(remoteId, home);
-                await this.host.syncFolders(remoteId, {
+                const ensureVm = () => this.host.syncFolders(remoteId, {
                     projectId,
                     kind: 'git',
-                    type: 'sendonly',
+                    type: owner === 'vm' ? 'sendonly' : 'receiveonly',
                     peerDeviceId: home.deviceId,
                     ignores: (0, file_sync_dto_1.gitIgnores)(true),
                     paused: true,
                 });
-                await this.files.ensureFolder({
+                const ensureHome = () => this.files.ensureFolder({
                     projectId,
                     kind: 'git',
-                    type: 'receiveonly',
+                    type: owner === 'home' ? 'sendonly' : 'receiveonly',
                     peerDeviceId: host.deviceId,
                     ignores: (0, file_sync_dto_1.gitIgnores)(true),
                     paused: true,
                 });
+                if (owner === 'vm') {
+                    await ensureHome();
+                    await ensureVm();
+                }
+                else {
+                    await ensureVm();
+                    await ensureHome();
+                }
                 await this.host.syncFolderType(remoteId, gitId, { paused: false });
                 await this.files.updateFolder(gitId, { paused: false });
                 await Promise.all([this.host.syncScan(remoteId, gitId), this.files.rescan(gitId)]);
@@ -198,17 +640,27 @@ let RemoteFileSyncService = class RemoteFileSyncService {
         if (!active())
             return;
         if (state.step === 'settle') {
-            const config = await this.files.folderConfiguration(gitId);
+            const config = owner === 'vm'
+                ? await this.files.folderConfiguration(gitId)
+                : await this.host.syncFolderConfiguration(remoteId, gitId);
             if (config.type !== 'receiveonly' || config.paused)
                 throw new Error('Git share is not receiving');
-            const [sender, receiver] = await Promise.all([
-                this.host.syncStatus(remoteId, gitId, this.files.device().deviceId),
-                this.files.status(gitId),
-            ]);
+            const [sender, receiver] = await Promise.all(owner === 'vm'
+                ? [
+                    this.host.syncStatus(remoteId, gitId, this.files.device().deviceId),
+                    this.files.status(gitId),
+                ]
+                : [
+                    this.files.status(gitId, (await this.host.syncDevice(remoteId)).deviceId),
+                    this.host.syncStatus(remoteId, gitId),
+                ]);
             if (!active())
                 return;
             if (receiver.state === 'idle' && receiver.receiveOnlyChangedFiles > 0) {
-                await this.files.revertLocalChanges(gitId);
+                if (owner === 'vm')
+                    await this.files.revertLocalChanges(gitId);
+                else
+                    await this.host.syncRevert(remoteId, gitId);
                 return;
             }
             if (!(0, file_sync_service_1.evaluateCompletion)(sender, receiver).done) {
@@ -229,15 +681,21 @@ let RemoteFileSyncService = class RemoteFileSyncService {
         if (!active())
             return;
         if (state.step === 'directions') {
-            await this.host.syncFolderType(remoteId, codeId, { type: 'sendreceive' });
-            await this.files.updateFolder(codeId, { type: 'sendreceive' });
+            await this.host.syncFolderType(remoteId, codeId, { type: 'sendreceive', paused: false });
+            await this.files.updateFolder(codeId, { type: 'sendreceive', paused: false });
             state.step = 'guard';
         }
         if (!active())
             return;
         if (state.step === 'guard') {
             if (state.hasGit) {
-                state.guardWarning = await this.guard.install(projectId, remoteId);
+                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;
             }
             state.step = 'done';
             state.warning = null;
@@ -248,19 +706,22 @@ exports.RemoteFileSyncService = RemoteFileSyncService;
 exports.RemoteFileSyncService = RemoteFileSyncService = __decorate([
     (0, common_1.Injectable)(),
     __param(3, (0, common_1.Inject)(remote_health_port_1.REMOTE_HEALTH_PORT)),
+    __param(7, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
     __metadata("design:paramtypes", [file_sync_service_1.FileSyncService,
         remote_host_client_1.RemoteHostClient,
         remote_bindings_service_1.RemoteBindingsService, Object, file_sync_managed_exclusions_store_1.FileSyncManagedExclusionsStore,
         git_service_1.GitService,
-        home_git_guard_service_1.HomeGitGuardService])
+        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])
 ], RemoteFileSyncService);
-function folderError(config, status) {
+function folderError(config, status, includeFailedFiles = true) {
     if (config.paused)
         return 'folder is paused';
     const message = status.error?.trim();
     if (message)
         return message;
-    if ((status.errors ?? 0) > 0)
+    if (includeFailedFiles && (status.errors ?? 0) > 0)
         return `${status.errors} files failed`;
     if (status.state === 'error')
         return 'folder is in an error state';