@indigoai-us/hq-cloud 6.16.62 → 6.16.63

package/dist/cli/share.test.js

@@ -1794,6 +1794,154 @@ describe("share", () => {
             vi.mocked(uploadFile).mockResolvedValue({ etag: '"upload-etag"' });
         }
     });
+    it("defers a breaker-tripped upload batch as one diagnostic company error", async () => {
+        // Production (2026-09-18 16:03Z brickcraft, 16:05Z mhi-media): the
+        // RateLimitBreaker tripped, remaining GET presigns all threw
+        // RateLimitedError, and throwUploadWorkerErrors rewrote the first into a
+        // hard throw (`… (and 4915 more upload-worker errors)`). The runner then
+        // put the company in errors[] and exited 2 even though every file is
+        // retried next sync. An all-transient worker batch is one diagnostic
+        // event at path "(company)", not a throw.
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const names = ["a.md", "b.md", "c.md"];
+        const journalPath = path.join(stateDir, "sync-journal.acme.json");
+        const staleHash = "stale-hash-for-old-content";
+        const files = {};
+        for (const name of names) {
+            fs.writeFileSync(path.join(companyRoot, name), `# ${name}`);
+            files[name] = {
+                hash: staleHash,
+                size: 5,
+                syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                direction: "up",
+                remoteEtag: "old-etag",
+            };
+        }
+        seedJournalAt(journalPath, {
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files,
+        });
+        vi.mocked(headRemoteFile).mockReset();
+        for (const _name of names) {
+            vi.mocked(headRemoteFile).mockImplementationOnce(async (_ctx, key) => {
+                throw new RateLimitedError(key, "get");
+            });
+        }
+        try {
+            const events = [];
+            const result = await share({
+                paths: names.map((name) => path.join(companyRoot, name)),
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+            });
+            expect(result.filesUploaded).toBe(0);
+            expect(uploadFile).not.toHaveBeenCalled();
+            for (const name of names) {
+                expect(journalAt(journalPath).files[name]).toMatchObject({
+                    hash: staleHash,
+                    remoteEtag: "old-etag",
+                });
+            }
+            const errorEvents = events.filter((e) => e.type === "error");
+            expect(errorEvents).toHaveLength(1);
+            expect(errorEvents[0]).toMatchObject({
+                type: "error",
+                diagnostic: true,
+                path: "(company)",
+                message: expect.stringMatching(/RateLimited.*\(and 2 more upload-worker errors\)/),
+            });
+            expect(events.some((e) => e.type === "error" && e.diagnostic !== true)).toBe(false);
+        }
+        finally {
+            vi.mocked(headRemoteFile).mockReset();
+            vi.mocked(headRemoteFile).mockResolvedValue(null);
+        }
+    });
+    it("still throws when an upload-worker batch includes a hard error", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const names = ["a.md", "b.md", "c.md"];
+        const journalPath = path.join(stateDir, "sync-journal.acme.json");
+        const staleHash = "stale-hash-for-old-content";
+        const files = {};
+        for (const name of names) {
+            fs.writeFileSync(path.join(companyRoot, name), `# ${name}`);
+            files[name] = {
+                hash: staleHash,
+                size: 5,
+                syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                direction: "up",
+                remoteEtag: "old-etag",
+            };
+        }
+        seedJournalAt(journalPath, {
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files,
+        });
+        vi.mocked(headRemoteFile).mockReset();
+        vi.mocked(headRemoteFile).mockImplementationOnce(async (_ctx, key) => {
+            throw new RateLimitedError(key, "get");
+        });
+        vi.mocked(headRemoteFile).mockImplementationOnce(async (_ctx, key) => {
+            throw new RateLimitedError(key, "get");
+        });
+        vi.mocked(headRemoteFile).mockImplementationOnce(async () => {
+            throw new Error("S3 boom");
+        });
+        const events = [];
+        let thrown;
+        try {
+            await share({
+                paths: names.map((name) => path.join(companyRoot, name)),
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+            });
+        }
+        catch (err) {
+            thrown = err;
+        }
+        finally {
+            vi.mocked(headRemoteFile).mockReset();
+            vi.mocked(headRemoteFile).mockResolvedValue(null);
+        }
+        expect(thrown).toBeInstanceOf(Error);
+        expect(thrown.message).toMatch(/S3 boom \(and 2 more upload-worker errors\)/);
+        expect(events.some((e) => e.type === "error")).toBe(false);
+        for (const name of names) {
+            expect(journalAt(journalPath).files[name]).toMatchObject({
+                hash: staleHash,
+                remoteEtag: "old-etag",
+            });
+        }
+    });
+    it("uploads a three-file batch when every worker succeeds", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const names = ["a.md", "b.md", "c.md"];
+        for (const name of names) {
+            fs.writeFileSync(path.join(companyRoot, name), `# ${name}`);
+        }
+        const events = [];
+        const result = await share({
+            paths: names.map((name) => path.join(companyRoot, name)),
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            onEvent: (e) => events.push(e),
+        });
+        expect(result.filesUploaded).toBe(3);
+        expect(result.aborted).toBe(false);
+        expect(events.some((e) => e.type === "error")).toBe(false);
+        const putKeys = vi.mocked(uploadFile).mock.calls.map((c) => c[2]).sort();
+        expect(putKeys).toEqual([...names]);
+    });
     it("replans an upload from the bytes present when its action starts", async () => {
         const companyRoot = path.join(tmpDir, "companies", "acme");
         fs.mkdirSync(companyRoot, { recursive: true });