@indigoai-us/hq-cloud 6.18.15 → 6.18.16-alpha.0

package/dist/cli/sync.test.js

@@ -4698,6 +4698,150 @@ describe("sync", () => {
         expect(journal.files["docs/deleted-by-peer.md"]).toBeUndefined();
         expect(journal.files["docs/kept.md"]).toBeDefined();
     });
+    it("does NOT delete a live file when a case-only folder rename leaves the old spelling in the journal (feedback_c8ed69d1)", async () => {
+        // Solace incident 2026-09-27. A teammate renamed `TikTok-Shop/` to
+        // `tiktok-shop/`. Another Mac still had the folder spelled `TikTok-Shop/`
+        // on disk and journal rows for the old keys. On its next pull the old keys
+        // were absent from the remote LIST, so the sweep lstat'ed
+        // `TikTok-Shop/plan.md`, found the file (the only copy, which is also the
+        // local file of the live key `tiktok-shop/plan.md` on a case-insensitive
+        // disk), saw the journal hash match, and unlinked it. The push leg then
+        // deleted 255 live keys from the vault.
+        //
+        // On a case-folding volume, a journal key whose case-folded spelling is
+        // still listed remotely is an alias of a live file: retire its journal row
+        // and leave the disk alone. `caseFoldingVolume` forces that volume
+        // behaviour so the test also runs on case-sensitive CI filesystems.
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(path.join(companyRoot, "TikTok-Shop"), { recursive: true });
+        fs.writeFileSync(path.join(companyRoot, "TikTok-Shop", "plan.md"), "live content");
+        const crypto = await import("node:crypto");
+        const liveHash = crypto.createHash("sha256").update("live content").digest("hex");
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files: {
+                "TikTok-Shop/plan.md": {
+                    hash: liveHash,
+                    size: 12,
+                    syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                    direction: "down",
+                    remoteEtag: "remote-old-spelling",
+                },
+                // An earlier pass already recorded the renamed key against the same
+                // bytes (on a case-insensitive disk it resolves to this file), so
+                // nothing is downloaded that could mask the sweep's unlink.
+                "tiktok-shop/plan.md": {
+                    hash: liveHash,
+                    size: 12,
+                    syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                    direction: "down",
+                    remoteEtag: "remote-new-spelling",
+                },
+            },
+        }));
+        // After the rename only the lower-case key is live in the vault.
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            {
+                key: "tiktok-shop/plan.md",
+                size: 12,
+                lastModified: new Date(),
+                etag: '"remote-new-spelling"',
+            },
+        ]);
+        const result = await sync({
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            caseFoldingVolume: true,
+        });
+        // The live file survives under the spelling that is on disk.
+        expect(fs.readFileSync(path.join(companyRoot, "TikTok-Shop", "plan.md"), "utf8")).toBe("live content");
+        expect(result.filesTombstoned).toBe(0);
+        // The stale old-spelling row is retired so the sweep does not revisit it.
+        const journal = journalAt(journalPath);
+        expect(journal.files["TikTok-Shop/plan.md"]).toBeUndefined();
+    });
+    it("does not let an invalid remote key protect a case-only twin from deletion", async () => {
+        // A malformed legacy object (`foo\\bar.md`) is skipped by remote-key
+        // validation. It never materializes locally, so it must not stop the sweep
+        // from deleting the remotely-deleted `Foo/bar.md`; otherwise the stale
+        // journal row is retired, the local file stays, and the next push
+        // resurrects it.
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(path.join(companyRoot, "Foo"), { recursive: true });
+        fs.writeFileSync(path.join(companyRoot, "Foo", "bar.md"), "old content");
+        const crypto = await import("node:crypto");
+        const oldHash = crypto.createHash("sha256").update("old content").digest("hex");
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files: {
+                "Foo/bar.md": {
+                    hash: oldHash,
+                    size: 11,
+                    syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                    direction: "down",
+                    remoteEtag: "remote-old",
+                },
+            },
+        }));
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            {
+                key: "foo\\bar.md",
+                size: 11,
+                lastModified: new Date(),
+                etag: '"remote-invalid"',
+            },
+        ]);
+        const result = await sync({
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            caseFoldingVolume: true,
+        });
+        expect(fs.existsSync(path.join(companyRoot, "Foo", "bar.md"))).toBe(false);
+        expect(result.filesTombstoned).toBe(1);
+        expect(journalAt(journalPath).files["Foo/bar.md"]).toBeUndefined();
+    });
+    it("still deletes a journal key on a case-folding volume when no live key shares its folded spelling", async () => {
+        // The case-alias guard must not turn off ordinary cross-machine deletes.
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(path.join(companyRoot, "TikTok-Shop"), { recursive: true });
+        fs.writeFileSync(path.join(companyRoot, "TikTok-Shop", "gone.md"), "old content");
+        const crypto = await import("node:crypto");
+        const oldHash = crypto.createHash("sha256").update("old content").digest("hex");
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files: {
+                "TikTok-Shop/gone.md": {
+                    hash: oldHash,
+                    size: 11,
+                    syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                    direction: "down",
+                    remoteEtag: "remote-old",
+                },
+            },
+        }));
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            {
+                key: "tiktok-shop/other.md",
+                size: 5,
+                lastModified: new Date(),
+                etag: '"remote-other"',
+            },
+        ]);
+        const result = await sync({
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            caseFoldingVolume: true,
+        });
+        expect(fs.existsSync(path.join(companyRoot, "TikTok-Shop", "gone.md"))).toBe(false);
+        expect(result.filesTombstoned).toBe(1);
+        expect(journalAt(journalPath).files["TikTok-Shop/gone.md"]).toBeUndefined();
+    });
     it("does NOT tombstone a live file recorded under a Windows backslash journal key whose POSIX twin still exists remotely (ridge data-loss regression — feedback_b8d09d0f)", async () => {
         // Root-cause regression. A pre-5.47.2 Windows client stamped the journal
         // key with path.sep ("\\"): `projects\forecast-development\...\sean-frank.csv`.