@indigoai-us/hq-cloud 6.18.22-alpha.732d → 6.18.23

package/dist/cli/sync.test.js

@@ -3820,6 +3820,323 @@ describe("sync", () => {
         expect(readJournal("acme").files["docs/handoff.md"]?.remoteEtag).toBe("new-etag");
         expect(fs.readFileSync(localPath, "utf8")).toBe(localContent);
     });
+    it("keeps local edits without a conflict or GET when a marked KMS-10 copy matches the baseline", async () => {
+        const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
+        fs.mkdirSync(companyDocs, { recursive: true });
+        const localPath = path.join(companyDocs, "handoff.md");
+        const baseline = "shared baseline";
+        const localEdit = "local edit with a different byte length";
+        fs.writeFileSync(localPath, localEdit);
+        const stat = fs.lstatSync(localPath);
+        const baselineHash = crypto.createHash("sha256").update(baseline).digest("hex");
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([
+            {
+                key: "docs/handoff.md",
+                size: Buffer.byteLength(baseline),
+                lastModified: new Date(),
+                etag: '"kms10-copy-etag"',
+            },
+        ]);
+        vi.mocked(s3Module.headRemoteFile).mockResolvedValueOnce({
+            etag: '"kms10-copy-etag"',
+            size: Buffer.byteLength(baseline),
+            lastModified: new Date(),
+            metadata: {
+                "hq-kms10-reencrypt-current": "true",
+                "hq-kms10-original-key-sha256": crypto.createHash("sha256").update("docs/handoff.md", "utf8").digest("hex"),
+                [s3Module.FILE_CONTENT_SHA256_META_KEY]: baselineHash,
+            },
+        });
+        writeJournal("acme", {
+            version: "2",
+            lastSync: new Date().toISOString(),
+            pulls: [],
+            files: {
+                "docs/handoff.md": {
+                    hash: baselineHash,
+                    size: Buffer.byteLength(baseline),
+                    mtimeMs: stat.mtimeMs - 1,
+                    ctimeMs: stat.ctimeMs - 1,
+                    remoteEtag: "old-kms-etag",
+                    syncedAt: new Date(Date.now() - 3600000).toISOString(),
+                    direction: "down",
+                    kind: "file",
+                },
+            },
+        });
+        const result = await sync({
+            company: "acme",
+            onConflict: "keep",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            pullPrefixes: ["docs/handoff.md"],
+            skipReindex: true,
+        });
+        expect(vi.mocked(s3Module.headRemoteFile)).toHaveBeenCalledTimes(1);
+        expect(result.conflicts).toBe(0);
+        expect(vi.mocked(s3Module.downloadFile)).not.toHaveBeenCalled();
+        expect(fs.readFileSync(localPath, "utf8")).toBe(localEdit);
+        expect(readJournal("acme").files["docs/handoff.md"]).toMatchObject({
+            hash: baselineHash,
+            remoteEtag: "kms10-copy-etag",
+        });
+    });
+    it("HEADs changed same-size candidates in bounded concurrent batches", async () => {
+        const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
+        fs.mkdirSync(companyDocs, { recursive: true });
+        const rows = [];
+        const journalFiles = {};
+        const heads = new Map();
+        for (let index = 0; index < 17; index += 1) {
+            const key = `docs/batch-${String(index).padStart(2, "0")}.md`;
+            const localPath = path.join(tmpDir, "companies", "acme", key);
+            const content = `baseline-${String(index).padStart(2, "0")}`;
+            fs.writeFileSync(localPath, content);
+            const stat = fs.lstatSync(localPath);
+            const hash = crypto.createHash("sha256").update(content).digest("hex");
+            const oldEtag = `old-etag-${index}`;
+            const newEtag = `new-etag-${index}`;
+            rows.push({ key, size: stat.size, lastModified: new Date(), etag: `"${newEtag}"` });
+            journalFiles[key] = {
+                hash,
+                size: stat.size,
+                mtimeMs: stat.mtimeMs,
+                ctimeMs: stat.ctimeMs,
+                remoteEtag: oldEtag,
+                syncedAt: new Date(Date.now() - 3_600_000).toISOString(),
+                direction: "down",
+                kind: "file",
+            };
+            heads.set(key, {
+                etag: `"${newEtag}"`,
+                size: stat.size,
+                lastModified: new Date(),
+                metadata: {
+                    "hq-kms10-reencrypt-current": "true",
+                    "hq-kms10-original-key-sha256": crypto.createHash("sha256").update(key, "utf8").digest("hex"),
+                    "hq-kms10-original-etag": oldEtag,
+                },
+            });
+        }
+        writeJournal("acme", {
+            version: "2",
+            lastSync: new Date().toISOString(),
+            pulls: [],
+            files: journalFiles,
+        });
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce(rows);
+        let active = 0;
+        let maximumActive = 0;
+        vi.mocked(s3Module.headRemoteFile).mockImplementation(async (_ctx, key) => {
+            active += 1;
+            maximumActive = Math.max(maximumActive, active);
+            // Hold each fake network operation long enough to observe overlap.
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            active -= 1;
+            return heads.get(key) ?? null;
+        });
+        const result = await sync({
+            company: "acme",
+            onConflict: "keep",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            pullPrefixes: ["docs/"],
+            skipReindex: true,
+        });
+        expect(result.conflicts).toBe(0);
+        expect(result.filesDownloaded).toBe(0);
+        expect(maximumActive).toBeGreaterThan(1);
+        expect(maximumActive).toBeLessThanOrEqual(16);
+        expect(maximumActive).toBe(16);
+    });
+    it("records a marked KMS-10 ETag when the baseline bytes match but local stat changed", async () => {
+        const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
+        fs.mkdirSync(companyDocs, { recursive: true });
+        const localPath = path.join(companyDocs, "handoff.md");
+        const baseline = "same content after a stat-only change";
+        fs.writeFileSync(localPath, baseline);
+        const stat = fs.lstatSync(localPath);
+        const baselineHash = crypto.createHash("sha256").update(baseline).digest("hex");
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([{
+                key: "docs/handoff.md",
+                size: Buffer.byteLength(baseline),
+                lastModified: new Date(),
+                etag: '"kms10-copy-etag"',
+            }]);
+        vi.mocked(s3Module.headRemoteFile).mockResolvedValueOnce({
+            etag: '"kms10-copy-etag"',
+            size: Buffer.byteLength(baseline),
+            lastModified: new Date(),
+            metadata: {
+                "hq-kms10-reencrypt-current": "true",
+                "hq-kms10-original-key-sha256": crypto.createHash("sha256").update("docs/handoff.md", "utf8").digest("hex"),
+                [s3Module.FILE_CONTENT_SHA256_META_KEY]: baselineHash,
+            },
+        });
+        writeJournal("acme", {
+            version: "2",
+            lastSync: new Date().toISOString(),
+            pulls: [],
+            files: {
+                "docs/handoff.md": {
+                    hash: baselineHash,
+                    size: Buffer.byteLength(baseline),
+                    mtimeMs: stat.mtimeMs - 1,
+                    ctimeMs: stat.ctimeMs - 1,
+                    remoteEtag: "old-kms-etag",
+                    syncedAt: new Date(Date.now() - 3600000).toISOString(),
+                    direction: "down",
+                    kind: "file",
+                },
+            },
+        });
+        const result = await sync({
+            company: "acme",
+            onConflict: "keep",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            pullPrefixes: ["docs/handoff.md"],
+            skipReindex: true,
+        });
+        expect(result.conflicts).toBe(0);
+        expect(vi.mocked(s3Module.downloadFile)).not.toHaveBeenCalled();
+        expect(fs.readFileSync(localPath, "utf8")).toBe(baseline);
+        expect(readJournal("acme").files["docs/handoff.md"]?.remoteEtag).toBe("kms10-copy-etag");
+    });
+    it.each([
+        { label: "unchanged", localTarget: "baseline-target.md" },
+        { label: "locally retargeted", localTarget: "new-local-target.md" },
+    ])("records a marked KMS-10 ETag for an $label symlink without a GET or conflict", async ({ localTarget }) => {
+        const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
+        fs.mkdirSync(companyDocs, { recursive: true });
+        const localPath = path.join(companyDocs, "link.md");
+        const baselineTarget = "baseline-target.md";
+        fs.symlinkSync(localTarget, localPath);
+        const stat = fs.lstatSync(localPath);
+        const baselineHash = journalModule.hashSymlinkTarget(baselineTarget);
+        // The remote body is the encoded link, so LIST reports its byte length
+        // while the journal records a symlink with size 0.
+        const remoteSize = Buffer.byteLength(`${s3Module.SYMLINK_BODY_PREFIX}${baselineTarget}`);
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([{
+                key: "docs/link.md",
+                size: remoteSize,
+                lastModified: new Date(),
+                etag: '"kms10-copy-etag"',
+            }]);
+        vi.mocked(s3Module.headRemoteFile).mockResolvedValueOnce({
+            etag: '"kms10-copy-etag"',
+            size: remoteSize,
+            lastModified: new Date(),
+            metadata: {
+                "hq-kms10-reencrypt-current": "true",
+                "hq-kms10-original-key-sha256": crypto.createHash("sha256").update("docs/link.md", "utf8").digest("hex"),
+                "hq-kms10-original-etag": "old-kms-etag",
+            },
+        });
+        writeJournal("acme", {
+            version: "2",
+            lastSync: new Date().toISOString(),
+            pulls: [],
+            files: {
+                "docs/link.md": {
+                    hash: baselineHash,
+                    size: 0,
+                    mtimeMs: stat.mtimeMs,
+                    ctimeMs: stat.ctimeMs,
+                    remoteEtag: "old-kms-etag",
+                    syncedAt: new Date(Date.now() - 3600000).toISOString(),
+                    direction: "down",
+                    kind: "symlink",
+                },
+            },
+        });
+        const result = await sync({
+            company: "acme",
+            onConflict: "keep",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            pullPrefixes: ["docs/link.md"],
+            skipReindex: true,
+        });
+        expect(vi.mocked(s3Module.headRemoteFile)).toHaveBeenCalledTimes(1);
+        expect(result.conflicts).toBe(0);
+        expect(vi.mocked(s3Module.downloadFile)).not.toHaveBeenCalled();
+        expect(fs.readlinkSync(localPath)).toBe(localTarget);
+        expect(readJournal("acme").files["docs/link.md"]).toMatchObject({
+            hash: baselineHash,
+            remoteEtag: "kms10-copy-etag",
+        });
+    });
+    it("leaves the journal unchanged and marks a retry when local bytes change after KMS-10 planning", async () => {
+        const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
+        fs.mkdirSync(companyDocs, { recursive: true });
+        const localPath = path.join(companyDocs, "handoff.md");
+        const baseline = "shared baseline";
+        const localEdit = "local edit that differs from baseline";
+        fs.writeFileSync(localPath, localEdit);
+        const stat = fs.lstatSync(localPath);
+        const baselineHash = crypto.createHash("sha256").update(baseline).digest("hex");
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([{
+                key: "docs/handoff.md",
+                size: Buffer.byteLength(baseline),
+                lastModified: new Date(),
+                etag: '"kms10-copy-etag"',
+            }]);
+        vi.mocked(s3Module.headRemoteFile).mockResolvedValueOnce({
+            etag: '"kms10-copy-etag"',
+            size: Buffer.byteLength(baseline),
+            lastModified: new Date(),
+            metadata: {
+                "hq-kms10-reencrypt-current": "true",
+                "hq-kms10-original-key-sha256": crypto.createHash("sha256").update("docs/handoff.md", "utf8").digest("hex"),
+                [s3Module.FILE_CONTENT_SHA256_META_KEY]: baselineHash,
+            },
+        });
+        writeJournal("acme", {
+            version: "2",
+            lastSync: new Date().toISOString(),
+            pulls: [],
+            files: {
+                "docs/handoff.md": {
+                    hash: baselineHash,
+                    size: Buffer.byteLength(baseline),
+                    mtimeMs: stat.mtimeMs - 1,
+                    ctimeMs: stat.ctimeMs - 1,
+                    remoteEtag: "old-kms-etag",
+                    syncedAt: new Date(Date.now() - 3600000).toISOString(),
+                    direction: "down",
+                    kind: "file",
+                },
+            },
+        });
+        const events = [];
+        const checkpointApply = vi.fn();
+        const result = await sync({
+            company: "acme",
+            onConflict: "keep",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            pullPrefixes: ["docs/handoff.md"],
+            skipReindex: true,
+            reconcileApply: { store: { checkpointApply }, cursor: {} },
+            onEvent: (event) => {
+                events.push(event);
+                if (event.type === "plan")
+                    fs.writeFileSync(localPath, "concurrent edit after planning");
+            },
+        });
+        expect(result.conflicts).toBe(0);
+        expect(vi.mocked(s3Module.downloadFile)).not.toHaveBeenCalled();
+        expect(fs.readFileSync(localPath, "utf8")).toBe("concurrent edit after planning");
+        expect(readJournal("acme").files["docs/handoff.md"]?.remoteEtag).toBe("old-kms-etag");
+        expect(checkpointApply).not.toHaveBeenCalled();
+        expect(events).toContainEqual(expect.objectContaining({
+            type: "error",
+            diagnostic: true,
+            path: "docs/handoff.md",
+            message: expect.stringContaining("local file changed after planning"),
+        }));
+    });
     it.each([
         "changed remote content hash",
         "locally modified file",