@indigoai-us/hq-cloud 6.18.16-alpha.main2 → 6.18.17

package/dist/cli/share.test.js

@@ -103,7 +103,9 @@ vi.mock("readline", () => ({
 import * as readline from "readline";
 import { share, ServerOwnedPushPathsError, UnreachablePushPathsError, UnregisteredCompanySkillError, currentUploadBytes, FULL_PUSH_COOPERATIVE_CHECKPOINT_BATCH_SIZE, parseRegisteredCompanySkillUid, setPushCollectCooperativeYieldMsForTesting, _testing as shareTesting, } from "./share.js";
 import { deleteRemoteFile, downloadFile, headRemoteFile, primeObjectTransport, primeUploads, setUploadContentHash, uploadFile, uploadSymlink, WindowsSymlinkPrivilegeError, } from "../s3.js";
-import { VaultAuthError, VaultClientError, VaultConflictError, VaultPermissionDeniedError, } from "../vault-client.js";
+import { VaultAuthError, VaultClientError, VaultConflictError, VaultPermissionDeniedError, vaultErrorFromResponse, } from "../vault-client.js";
+import { PLAN_LIMIT_UPGRADE_URL, canonicalPlanLimitBody, legacyMembershipPlanLimitBody, } from "../plan-limit.fixtures.js";
+import { PLAN_LIMIT_PAUSE_RETRY_MS, PlanLimitPauseStore, setPlanLimitPauseClockForTesting, } from "../plan-limit-pause.js";
 import { CognitoRefreshError } from "../cognito-auth.js";
 import { RateLimitedError } from "../object-io.js";
 import { resolveSkillRegisterLandedBytes } from "../lib/skill-register-landed-bytes.js";
@@ -2132,36 +2134,278 @@ describe("share", () => {
         });
         expect(journalAt(journalPath).files[secretKey]?.removedAt).toBeUndefined();
     });
-    it("emits one server-linked plan-limit notice for a multi-file upload pass", async () => {
-        const companyRoot = path.join(tmpDir, "companies", "acme");
-        const paths = ["first.md", "second.md"].map((name) => {
-            const file = path.join(companyRoot, name);
-            fs.mkdirSync(path.dirname(file), { recursive: true });
-            fs.writeFileSync(file, "# paused by plan limit");
-            return file;
+    describe("plan-limit refusals", () => {
+        const T0 = Date.parse("2026-09-28T12:00:00.000Z");
+        let clock = T0;
+        beforeEach(() => {
+            clock = T0;
+            setPlanLimitPauseClockForTesting(() => clock);
         });
-        const upgradeUrl = "https://billing.example.test/company/acme";
-        vi.mocked(uploadFile).mockReset();
-        vi.mocked(uploadFile).mockRejectedValue(new VaultClientError("Plan limit reached", 402, JSON.stringify({ code: "plan_limit_reached", upgradeUrl }), { code: "plan_limit_reached", upgradeUrl }));
-        const events = [];
-        try {
+        afterEach(() => {
+            setPlanLimitPauseClockForTesting(null);
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockResolvedValue({ etag: '"upload-etag"' });
+        });
+        function writeCompanyFiles(names) {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            return names.map((name) => {
+                const file = path.join(companyRoot, name);
+                fs.mkdirSync(path.dirname(file), { recursive: true });
+                fs.writeFileSync(file, `# ${name} paused by plan limit`);
+                return file;
+            });
+        }
+        /** The error the vault client throws for the server's canonical 402 body. */
+        function canonical402() {
+            return vaultErrorFromResponse(402, JSON.stringify(canonicalPlanLimitBody()));
+        }
+        function collect() {
+            const events = [];
+            return { events, onEvent: (event) => events.push(event) };
+        }
+        it("reports one notice with the refused files, the server message and the upgrade link", async () => {
+            const paths = writeCompanyFiles(["first.md", "second.md"]);
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockRejectedValue(canonical402());
+            const { events, onEvent } = collect();
             const result = await share({
                 paths,
                 company: "acme",
                 vaultConfig: mockConfig,
                 hqRoot: tmpDir,
-                onEvent: (event) => events.push(event),
+                onEvent,
             });
             const notices = events.filter((event) => event.type === "plan-limit");
-            expect(notices).toEqual([{ type: "plan-limit", upgradeUrl }]);
+            expect(notices).toEqual([
+                {
+                    type: "plan-limit",
+                    upgradeUrl: PLAN_LIMIT_UPGRADE_URL,
+                    message: "New files are paused while Acme is over its Starter limits.",
+                    code: "PLAN_LIMIT_EXCEEDED",
+                    error: "plan_limit_reached",
+                    blocked: "files.create",
+                    resources: [
+                        { resource: "storageBytes", used: 11_811_160_064, limit: 10_737_418_240 },
+                    ],
+                    fixOptions: { storageBytes: 10_737_418_240 },
+                    freeMonth: {
+                        eligible: true,
+                        trialDays: 30,
+                        url: "https://billing.example.test/companies/acme/billing?offer=free-month",
+                    },
+                    count: 2,
+                    paths: expect.arrayContaining(["first.md", "second.md"]),
+                    pausedUntil: new Date(T0 + PLAN_LIMIT_PAUSE_RETRY_MS).toISOString(),
+                    fromPause: false,
+                },
+            ]);
             expect(events.some((event) => event.type === "error")).toBe(false);
             expect(result.filesUploaded).toBe(0);
             expect(result.filesSkipped).toBe(2);
-        }
-        finally {
+            expect(result.filesPlanLimited).toBe(2);
+            expect(result.planLimitedPaths?.sort()).toEqual(["first.md", "second.md"]);
+            expect(result.planLimit?.upgradeUrl).toBe(PLAN_LIMIT_UPGRADE_URL);
+            // The refusal is recorded so the runner does not presign these again.
+            const pauses = PlanLimitPauseStore.open("cmp_01ABCDEF");
+            expect(pauses.isPaused("first.md", T0)).toBe(true);
+            expect(pauses.isPaused("second.md", T0)).toBe(true);
+        });
+        it("recognises the legacy membership 402 shape the same way", async () => {
+            const paths = writeCompanyFiles(["legacy.md"]);
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockRejectedValue(vaultErrorFromResponse(402, JSON.stringify(legacyMembershipPlanLimitBody())));
+            const { events, onEvent } = collect();
+            const result = await share({ paths, company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir, onEvent });
+            expect(events.filter((e) => e.type === "plan-limit")).toEqual([
+                expect.objectContaining({ upgradeUrl: PLAN_LIMIT_UPGRADE_URL, count: 1, paths: ["legacy.md"] }),
+            ]);
+            expect(events.some((event) => event.type === "error")).toBe(false);
+            expect(result.filesPlanLimited).toBe(1);
+        });
+        it("with planLimitPause, skips paused files without uploading until the hour lapses", async () => {
+            const paths = writeCompanyFiles(["a.md", "b.md", "c.md"]);
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockRejectedValue(canonical402());
+            const pass = async () => {
+                const { events, onEvent } = collect();
+                const result = await share({
+                    paths,
+                    company: "acme",
+                    vaultConfig: mockConfig,
+                    hqRoot: tmpDir,
+                    skipUnchanged: true,
+                    planLimitPause: true,
+                    onEvent,
+                });
+                return { events, result };
+            };
+            const first = await pass();
+            expect(vi.mocked(uploadFile)).toHaveBeenCalledTimes(3);
+            expect(first.events.filter((e) => e.type === "plan-limit")).toHaveLength(1);
+            for (let i = 0; i < 4; i++) {
+                clock += 10 * 60 * 1000;
+                const next = await pass();
+                // Still announced every pass, from the stored refusal.
+                expect(next.events.filter((e) => e.type === "plan-limit")).toEqual([
+                    expect.objectContaining({
+                        fromPause: true,
+                        count: 3,
+                        upgradeUrl: PLAN_LIMIT_UPGRADE_URL,
+                        message: "New files are paused while Acme is over its Starter limits.",
+                        pausedUntil: new Date(T0 + PLAN_LIMIT_PAUSE_RETRY_MS).toISOString(),
+                    }),
+                ]);
+                expect(next.events.some((e) => e.type === "error")).toBe(false);
+                expect(next.result.filesUploaded).toBe(0);
+                expect(next.result.filesPlanLimited).toBe(3);
+                expect(next.result.planLimit?.upgradeUrl).toBe(PLAN_LIMIT_UPGRADE_URL);
+            }
+            // Four more passes inside the hour: no further upload attempts.
+            expect(vi.mocked(uploadFile)).toHaveBeenCalledTimes(3);
+            clock = T0 + PLAN_LIMIT_PAUSE_RETRY_MS;
+            const retry = await pass();
+            expect(vi.mocked(uploadFile)).toHaveBeenCalledTimes(6);
+            expect(retry.events.filter((e) => e.type === "plan-limit")).toEqual([
+                expect.objectContaining({ count: 3, fromPause: false }),
+            ]);
+        });
+        it("announces files a direct push paused when the runner then skips them (fromPause)", async () => {
+            const paths = writeCompanyFiles(["a.md", "b.md"]);
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockRejectedValue(canonical402());
+            // `hq sync push` (no planLimitPause) refuses a.md and b.md and records
+            // the pauses, but does not obey them itself.
+            await share({ paths, company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir, onEvent: () => { } });
+            expect(vi.mocked(uploadFile)).toHaveBeenCalledTimes(2);
+            // Twenty minutes later the runner (or a restarted desktop) skips them.
+            // It must say so: one plan-limit event built from the stored refusal.
+            clock = T0 + 20 * 60 * 1000;
+            const { events, onEvent } = collect();
+            const result = await share({
+                paths,
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                planLimitPause: true,
+                onEvent,
+            });
+            expect(vi.mocked(uploadFile)).toHaveBeenCalledTimes(2);
+            expect(result.filesPlanLimited).toBe(2);
+            expect(events.filter((e) => e.type === "plan-limit")).toEqual([
+                {
+                    type: "plan-limit",
+                    upgradeUrl: PLAN_LIMIT_UPGRADE_URL,
+                    message: "New files are paused while Acme is over its Starter limits.",
+                    code: "PLAN_LIMIT_EXCEEDED",
+                    error: "plan_limit_reached",
+                    blocked: "files.create",
+                    resources: [
+                        { resource: "storageBytes", used: 11_811_160_064, limit: 10_737_418_240 },
+                    ],
+                    fixOptions: { storageBytes: 10_737_418_240 },
+                    freeMonth: {
+                        eligible: true,
+                        trialDays: 30,
+                        url: "https://billing.example.test/companies/acme/billing?offer=free-month",
+                    },
+                    count: 2,
+                    paths: expect.arrayContaining(["a.md", "b.md"]),
+                    pausedUntil: new Date(T0 + PLAN_LIMIT_PAUSE_RETRY_MS).toISOString(),
+                    fromPause: true,
+                },
+            ]);
+            expect(events.some((e) => e.type === "error")).toBe(false);
+        });
+        it("reports fresh refusals and paused skips together in one event", async () => {
+            const [first] = writeCompanyFiles(["first.md"]);
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockRejectedValue(canonical402());
+            await share({
+                paths: [first],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                planLimitPause: true,
+                onEvent: () => { },
+            });
+            clock = T0 + 30 * 60 * 1000;
+            const [second] = writeCompanyFiles(["second.md"]);
+            const { events, onEvent } = collect();
+            await share({
+                paths: [first, second],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                planLimitPause: true,
+                onEvent,
+            });
+            expect(events.filter((e) => e.type === "plan-limit")).toEqual([
+                expect.objectContaining({
+                    fromPause: false,
+                    count: 2,
+                    paths: ["second.md", "first.md"],
+                    // The earliest retry: first.md's pause from T0.
+                    pausedUntil: new Date(T0 + PLAN_LIMIT_PAUSE_RETRY_MS).toISOString(),
+                }),
+            ]);
+        });
+        it("without planLimitPause (a direct push), retries and reports refused files every time", async () => {
+            const paths = writeCompanyFiles(["a.md"]);
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockRejectedValue(canonical402());
+            for (let i = 0; i < 2; i++) {
+                const { events, onEvent } = collect();
+                await share({ paths, company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir, skipUnchanged: true, onEvent });
+                expect(events.filter((e) => e.type === "plan-limit")).toHaveLength(1);
+            }
+            expect(vi.mocked(uploadFile)).toHaveBeenCalledTimes(2);
+        });
+        it("drops every pause once an upload to the same vault succeeds", async () => {
+            const [paused] = writeCompanyFiles(["paused.md"]);
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockRejectedValue(canonical402());
+            await share({
+                paths: [paused],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                planLimitPause: true,
+                onEvent: () => { },
+            });
+            expect(PlanLimitPauseStore.open("cmp_01ABCDEF").isPaused("paused.md", clock)).toBe(true);
+            // The plan changed: the server accepts writes again. A new file uploads,
+            // which clears the record so the paused file is retried next pass.
             vi.mocked(uploadFile).mockReset();
             vi.mocked(uploadFile).mockResolvedValue({ etag: '"upload-etag"' });
-        }
+            const [fresh] = writeCompanyFiles(["fresh.md"]);
+            const accepted = await share({
+                paths: [paused, fresh],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                planLimitPause: true,
+                onEvent: () => { },
+            });
+            expect(accepted.filesUploaded).toBe(1);
+            expect(accepted.filesPlanLimited).toBe(1);
+            expect(PlanLimitPauseStore.open("cmp_01ABCDEF").size).toBe(0);
+            const next = await share({
+                paths: [paused, fresh],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                planLimitPause: true,
+                onEvent: () => { },
+            });
+            expect(next.filesUploaded).toBe(1);
+            expect(next.filesPlanLimited).toBe(0);
+        });
     });
     it("hands queued realtime work a settled full-push boundary without losing journal rows", async () => {
         const companyRoot = path.join(tmpDir, "companies", "acme");