@indigoai-us/hq-cloud 6.15.12 → 6.15.13

package/dist/cli/share.test.js

@@ -52,7 +52,7 @@ vi.mock("readline", () => ({
     })),
 }));
 import * as readline from "readline";
-import { share, isForbiddenCompanyVaultKey, UnreachablePushPathsError, _testing as shareTesting } from "./share.js";
+import { share, isForbiddenCompanyVaultKey, UnreachablePushPathsError, currentUploadBytes, _testing as shareTesting } from "./share.js";
 import { deleteRemoteFile, downloadFile, headRemoteFile, uploadFile, uploadSymlink, WindowsSymlinkPrivilegeError } from "../s3.js";
 import { VaultAuthError } from "../vault-client.js";
 import { hashFile } from "../journal.js";
@@ -5873,6 +5873,50 @@ describe("currency-gated: journal version 2 fixtures", () => {
     // still fire (now at file-settle time, not plan-walk time) so the menubar
     // stream parser sees the same shape. Aborts mid-batch let in-flight PUTs
     // finish but stop queueing new ones.
+    describe("currentUploadBytes (byte-budget admission size)", () => {
+        it("returns the CURRENT on-disk size, not a stale planned size", () => {
+            const dir = fs.mkdtempSync(path.join(os.tmpdir(), "cub-grow-"));
+            try {
+                const abs = path.join(dir, "grew.log");
+                fs.writeFileSync(abs, Buffer.alloc(5000)); // on disk NOW: 5000 bytes
+                const item = {
+                    action: "upload",
+                    kind: "file",
+                    absolutePath: abs,
+                    relativePath: "grew.log",
+                    localHash: "h",
+                    size: 10, // stale planned size
+                };
+                expect(currentUploadBytes(item)).toBe(5000);
+            }
+            finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        });
+        it("returns 0 for a symlink (empty wire body)", () => {
+            const item = {
+                action: "upload",
+                kind: "symlink",
+                absolutePath: "/nonexistent/link",
+                relativePath: "link",
+                target: "target",
+                localHash: "h",
+                size: 0,
+            };
+            expect(currentUploadBytes(item)).toBe(0);
+        });
+        it("falls back to the planned size when the file cannot be stat'd", () => {
+            const item = {
+                action: "upload",
+                kind: "file",
+                absolutePath: "/nonexistent/x.bin",
+                relativePath: "x.bin",
+                localHash: "h",
+                size: 42,
+            };
+            expect(currentUploadBytes(item)).toBe(42);
+        });
+    });
     describe("parallel upload pool (5.36.0)", () => {
         it("runs uploads with measurable parallelism (8+ in flight before first settles)", async () => {
             const companyRoot = path.join(tmpDir, "companies", "acme");
@@ -5999,6 +6043,91 @@ describe("currency-gated: journal version 2 fixtures", () => {
                 delete process.env.HQ_SYNC_TRANSFER_CONCURRENCY;
             }
         });
+        it("byte budget caps in-flight uploads below the worker count", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            // 10 files of exactly 2048 bytes each.
+            for (let i = 0; i < 10; i++) {
+                fs.writeFileSync(path.join(companyRoot, `f-${i}.bin`), Buffer.alloc(2048));
+            }
+            // Worker count is high (16) so it is NOT the limiter; the byte budget is.
+            // 0.0048 MiB = 5033 bytes: two 2048-byte bodies fit (4096), three do not
+            // (6144), so at most 2 uploads may be in flight regardless of the 16 slots.
+            process.env.HQ_SYNC_TRANSFER_CONCURRENCY = "16";
+            process.env.HQ_SYNC_UPLOAD_BYTE_BUDGET_MB = "0.0048";
+            const startTimes = [];
+            const endTimes = [];
+            vi.mocked(uploadFile).mockImplementation(async () => {
+                startTimes.push(Date.now());
+                await new Promise((r) => setTimeout(r, 30));
+                endTimes.push(Date.now());
+                return { etag: '"upload-etag"' };
+            });
+            try {
+                const result = await share({
+                    paths: [companyRoot],
+                    company: "acme",
+                    vaultConfig: mockConfig,
+                    hqRoot: tmpDir,
+                    onConflict: "keep",
+                });
+                expect(result.filesUploaded).toBe(10); // all made progress, no deadlock
+                const sortedEvents = [];
+                for (const t of startTimes)
+                    sortedEvents.push({ t, kind: "start" });
+                for (const t of endTimes)
+                    sortedEvents.push({ t, kind: "end" });
+                sortedEvents.sort((a, b) => a.t - b.t || (a.kind === "end" ? -1 : 1));
+                let cur = 0;
+                let maxConcurrent = 0;
+                for (const ev of sortedEvents) {
+                    if (ev.kind === "start") {
+                        cur++;
+                        if (cur > maxConcurrent)
+                            maxConcurrent = cur;
+                    }
+                    else {
+                        cur--;
+                    }
+                }
+                // Byte-limited to 2, far below the 16-slot worker cap.
+                expect(maxConcurrent).toBeLessThanOrEqual(2);
+            }
+            finally {
+                delete process.env.HQ_SYNC_TRANSFER_CONCURRENCY;
+                delete process.env.HQ_SYNC_UPLOAD_BYTE_BUDGET_MB;
+            }
+        });
+        it("a file larger than the whole byte budget still uploads (no deadlock)", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            // Three 4096-byte files against a ~1 KiB budget: each exceeds the budget
+            // alone, so the "admit one when nothing is in flight" escape hatch must
+            // let every file through one at a time instead of wedging the pool.
+            for (let i = 0; i < 3; i++) {
+                fs.writeFileSync(path.join(companyRoot, `big-${i}.bin`), Buffer.alloc(4096));
+            }
+            process.env.HQ_SYNC_TRANSFER_CONCURRENCY = "16";
+            process.env.HQ_SYNC_UPLOAD_BYTE_BUDGET_MB = "0.001"; // 1048 bytes < 4096
+            vi.mocked(uploadFile).mockImplementation(async () => {
+                await new Promise((r) => setTimeout(r, 10));
+                return { etag: '"upload-etag"' };
+            });
+            try {
+                const result = await share({
+                    paths: [companyRoot],
+                    company: "acme",
+                    vaultConfig: mockConfig,
+                    hqRoot: tmpDir,
+                    onConflict: "keep",
+                });
+                expect(result.filesUploaded).toBe(3);
+            }
+            finally {
+                delete process.env.HQ_SYNC_TRANSFER_CONCURRENCY;
+                delete process.env.HQ_SYNC_UPLOAD_BYTE_BUDGET_MB;
+            }
+        });
         it("one failed upload does not abort sibling uploads in the pool", async () => {
             const companyRoot = path.join(tmpDir, "companies", "acme");
             fs.mkdirSync(companyRoot, { recursive: true });