@indigoai-us/hq-cloud 6.15.80 → 6.15.82

package/dist/cli/sync.test.js

@@ -691,6 +691,95 @@ describe("sync", () => {
         expect(errs[0].path).toBe("docs/x.md");
         expect(events.some((e) => e.type === "skip-symlink-privilege")).toBe(false);
     });
+    it("HQ-DESKTOP-54 (second path): a Windows rename refusal on the install is a deliberate skip (never type:error) and is left unjournaled", async () => {
+        // The reopening path: an EPERM/EBUSY rename that outlasts the bounded win32
+        // retry surfaces from s3 as a typed WindowsRenameBlockedError. downloadOne
+        // must downgrade it to skip-rename-blocked — NOT type:"error" — so the
+        // runner never counts it toward errors[] and never exits 2. The refused key
+        // must also stay unjournaled so a later, unblocked pass retries it.
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            { key: "projects/demo/note.md", size: 10, lastModified: new Date(), etag: '"note"' },
+        ]);
+        vi.mocked(s3Module.downloadFile).mockRejectedValueOnce(new s3Module.WindowsRenameBlockedError("dest", "EPERM"));
+        const events = [];
+        const result = await sync({
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            skipReindex: true,
+            onEvent: (e) => events.push(e),
+        });
+        const skip = events.find((e) => e.type === "skip-rename-blocked");
+        expect(skip).toMatchObject({ type: "skip-rename-blocked", path: "projects/demo/note.md" });
+        expect(skip.remedy).toMatch(/holding this file open/i);
+        expect(events.some((e) => e.type === "error")).toBe(false);
+        expect(result.filesSkipped).toBeGreaterThanOrEqual(1);
+        expect(result.filesDownloaded).toBe(0);
+        expect(getEntry(readJournal("acme"), "projects/demo/note.md")).toBeUndefined();
+    });
+    it("HQ-DESKTOP-54 (second path) convergence: after a refused pass, the next pass that CAN install journals it (no manual reset)", async () => {
+        const remote = [
+            { key: "projects/demo/note.md", size: 10, lastModified: new Date(), etag: '"note"' },
+        ];
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce(remote);
+        vi.mocked(s3Module.downloadFile).mockRejectedValueOnce(new s3Module.WindowsRenameBlockedError("dest", "EPERM"));
+        await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir, skipReindex: true });
+        expect(getEntry(readJournal("acme"), "projects/demo/note.md")).toBeUndefined();
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce(remote);
+        vi.mocked(s3Module.downloadFile).mockImplementationOnce(async (_ctx, _key, localPath) => {
+            fs.mkdirSync(path.dirname(localPath), { recursive: true });
+            fs.writeFileSync(localPath, "remote body");
+            return { metadata: {}, contentHash: "h", contentSize: 11 };
+        });
+        const result = await sync({
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            skipReindex: true,
+        });
+        expect(result.filesDownloaded).toBe(1);
+        expect(getEntry(readJournal("acme"), "projects/demo/note.md")).toBeDefined();
+    });
+    it("an EACCES install rename is NOT downgraded — it stays a type:error (only the transient EPERM/EBUSY family is a skip)", async () => {
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            { key: "projects/demo/note.md", size: 10, lastModified: new Date(), etag: '"note"' },
+        ]);
+        // s3 propagates a raw EACCES (an ACL-denied destination) unchanged — it is
+        // never wrapped as WindowsRenameBlockedError — so downloadOne errors it.
+        vi.mocked(s3Module.downloadFile).mockRejectedValueOnce(errnoError("EACCES"));
+        const events = [];
+        await sync({
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            skipReindex: true,
+            onEvent: (e) => events.push(e),
+        });
+        expect(events.some((e) => e.type === "skip-rename-blocked")).toBe(false);
+        const errs = events.filter((e) => e.type === "error");
+        expect(errs).toHaveLength(1);
+        expect(errs[0].path).toBe("projects/demo/note.md");
+    });
+    it("the default console logger renders the rename-blocked skip and its remedy (a plain `hq sync` is not silent)", async () => {
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            { key: "projects/demo/note.md", size: 10, lastModified: new Date(), etag: '"note"' },
+        ]);
+        vi.mocked(s3Module.downloadFile).mockRejectedValueOnce(new s3Module.WindowsRenameBlockedError("dest", "EPERM"));
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const log = vi.spyOn(console, "log").mockImplementation(() => { });
+        let rendered = [];
+        try {
+            // No onEvent → defaultConsoleLogger handles rendering.
+            await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir, skipReindex: true });
+            // Capture BEFORE mockRestore(), which clears recorded calls.
+            rendered = warn.mock.calls.map((c) => String(c[0]));
+        }
+        finally {
+            warn.mockRestore();
+            log.mockRestore();
+        }
+        expect(rendered.some((line) => /projects\/demo\/note\.md skipped/.test(line) && /holding the file open/i.test(line))).toBe(true);
+    });
     it("HQ-DESKTOP-54: a privilege refusal during the conflict-convergence probe is a skip, not an error or a counted conflict", async () => {
         // The conflict path also materializes the remote object (to compare it
         // against the diverged local copy). On an unprivileged Windows host that
@@ -1086,6 +1175,116 @@ describe("sync", () => {
         // here would re-create the deadlock this test exists to prevent.
         expect(entry.localDiverges).toBeFalsy();
     });
+    it("HQ-DESKTOP-54 (second path): a blocked conflict-keep preserve rename is a skip that does NOT strand the file (no holdLocal, no localDiverges)", async () => {
+        const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
+        fs.mkdirSync(companyDocs, { recursive: true });
+        const originalPath = path.join(companyDocs, "handoff.md");
+        fs.writeFileSync(originalPath, "local version");
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            { key: "docs/handoff.md", size: 42, lastModified: new Date(), etag: '"divergent"' },
+        ]);
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "1",
+            lastSync: new Date().toISOString(),
+            files: {
+                "docs/handoff.md": {
+                    hash: "old-hash-from-last-sync",
+                    size: 20,
+                    syncedAt: new Date(Date.now() - 3600000).toISOString(),
+                    direction: "down",
+                },
+            },
+        }));
+        // A held local file: the move-aside EPERMs. On win32 s3 raises the typed
+        // WindowsRenameBlockedError immediately (no retry).
+        const realRenameSync = fs.renameSync;
+        const renameSpy = vi.spyOn(fs, "renameSync").mockImplementation((from, to) => {
+            if (String(from) === originalPath && String(to).includes(".conflict-")) {
+                throw errnoError("EPERM");
+            }
+            return realRenameSync(from, to);
+        });
+        const realPlatform = process.platform;
+        Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+        const events = [];
+        try {
+            await sync({
+                company: "acme",
+                onConflict: "keep",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+            });
+        }
+        finally {
+            Object.defineProperty(process, "platform", { value: realPlatform, configurable: true });
+            renameSpy.mockRestore();
+        }
+        // Deliberate skip, never an error → runner stays exit 0.
+        expect(events.some((e) => e.type === "skip-rename-blocked")).toBe(true);
+        expect(events.some((e) => e.type === "error")).toBe(false);
+        // The operator's file is untouched (nothing moved, remote not adopted).
+        expect(fs.readFileSync(originalPath, "utf-8")).toBe("local version");
+        // NOT stranded: holdLocal did not run, so no remote etag was stamped and
+        // localDiverges was not armed — the conflict simply re-fires next pass.
+        const entry = journalAt(journalPath).files["docs/handoff.md"];
+        expect(entry.remoteEtag).toBeFalsy();
+        expect(entry.localDiverges).toBeFalsy();
+    });
+    it("conflict-keep preserve: a non-downgradable EACCES stays the existing type:error, whose tail now carries the code= token (instrumentation guard)", async () => {
+        const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
+        fs.mkdirSync(companyDocs, { recursive: true });
+        const originalPath = path.join(companyDocs, "handoff.md");
+        fs.writeFileSync(originalPath, "local version");
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            { key: "docs/handoff.md", size: 42, lastModified: new Date(), etag: '"divergent"' },
+        ]);
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "1",
+            lastSync: new Date().toISOString(),
+            files: {
+                "docs/handoff.md": {
+                    hash: "old-hash-from-last-sync",
+                    size: 20,
+                    syncedAt: new Date(Date.now() - 3600000).toISOString(),
+                    direction: "down",
+                },
+            },
+        }));
+        const realRenameSync = fs.renameSync;
+        const renameSpy = vi.spyOn(fs, "renameSync").mockImplementation((from, to) => {
+            if (String(from) === originalPath && String(to).includes(".conflict-")) {
+                throw errnoError("EACCES");
+            }
+            return realRenameSync(from, to);
+        });
+        const realPlatform = process.platform;
+        Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+        const events = [];
+        try {
+            await sync({
+                company: "acme",
+                onConflict: "keep",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+            });
+        }
+        finally {
+            Object.defineProperty(process, "platform", { value: realPlatform, configurable: true });
+            renameSpy.mockRestore();
+        }
+        expect(events.some((e) => e.type === "skip-rename-blocked")).toBe(false);
+        const err = events.find((e) => e.type === "error");
+        expect(err).toBeDefined();
+        // Literal prefix byte-identical (desktop shape vocabulary keeps matching);
+        // the tail now carries the parseable cause token.
+        expect(err.message.startsWith("conflict keep could not preserve the local copy: ")).toBe(true);
+        expect(err.message).toContain("code=EACCES");
+        // The existing holdLocal path still fires for a non-downgradable errno.
+        const entry = journalAt(journalPath).files["docs/handoff.md"];
+        expect(entry.localDiverges).toBe(true);
+    });
     it("conflict keep records the REMOTE body's hash, so the entry is pushable instead of permanently divergent", async () => {
         // This is the deadlock in one assertion. The old `keep` wrote the LOCAL
         // hash next to the REMOTE etag, which is a self-contradictory entry: the