@indigoai-us/hq-cloud 6.16.59 → 6.16.61

package/dist/cli/share.test.js

@@ -68,6 +68,7 @@ import { share, ServerOwnedPushPathsError, UnreachablePushPathsError, Unregister
 import { deleteRemoteFile, downloadFile, headRemoteFile, primeObjectTransport, primeUploads, uploadFile, uploadSymlink, WindowsSymlinkPrivilegeError, } from "../s3.js";
 import { VaultAuthError, VaultClientError, VaultConflictError, VaultPermissionDeniedError, } from "../vault-client.js";
 import { CognitoRefreshError } from "../cognito-auth.js";
+import { RateLimitedError } from "../object-io.js";
 import { AreaLedgerMigration, closeCachedAreaJournalMigration, hashFile, openJournalStateStoreForMigration, readJournal, readJournalScoped, setAreaLedgerMigrationTestHooksForTest, writeJournal, } from "../journal.js";
 import { ReconcileCursorStore } from "../sync/reconcile-cursor.js";
 import { AreaResolver } from "../sync/area-resolver.js";
@@ -1674,6 +1675,125 @@ describe("share", () => {
         // Remote key must be company-relative, not hqRoot-relative
         expect(uploadFile).toHaveBeenCalledWith(expect.anything(), testFile, "test.md", undefined, expect.anything());
     });
+    it("defers a rate-limited upload as a diagnostic error and leaves the journal row unchanged", async () => {
+        // Production (2026-09-18): vault 100/hr throttle on a per-file PUT was
+        // emitted as a hard type:"error", so the company landed in errors[] and
+        // hq-sync-runner exited 2 even though the journal row is untouched and
+        // the next pass re-plans the PUT. Rate-limit deferrals reuse the
+        // diagnostic marker; the file is not counted as uploaded.
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const testFile = path.join(companyRoot, "test.md");
+        fs.writeFileSync(testFile, "# Hello World");
+        const journalPath = path.join(stateDir, "sync-journal.acme.json");
+        const staleHash = "stale-hash-for-old-content";
+        seedJournalAt(journalPath, {
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files: {
+                "test.md": {
+                    hash: staleHash,
+                    size: 5,
+                    syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                    direction: "up",
+                    remoteEtag: "old-etag",
+                },
+            },
+        });
+        vi.mocked(uploadFile).mockReset();
+        let putAttempted = false;
+        vi.mocked(uploadFile).mockImplementationOnce(async (_ctx, _localPath, key) => {
+            expect(key).toBe("test.md");
+            putAttempted = true;
+            throw new RateLimitedError("test.md", "put");
+        });
+        try {
+            const events = [];
+            const result = await share({
+                paths: [testFile],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+            });
+            expect(putAttempted).toBe(true);
+            expect(result.filesUploaded).toBe(0);
+            expect(result.filesSkipped).toBeGreaterThanOrEqual(1);
+            expect(journalAt(journalPath).files["test.md"]).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: "test.md",
+                message: expect.stringMatching(/RateLimited.*put test.md deferred to next sync/),
+            });
+            expect(events.some((e) => e.type === "error" && e.diagnostic !== true)).toBe(false);
+        }
+        finally {
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockResolvedValue({ etag: '"upload-etag"' });
+        }
+    });
+    it("still emits a hard error when upload throws a generic Error", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const testFile = path.join(companyRoot, "test.md");
+        fs.writeFileSync(testFile, "# Hello World");
+        const journalPath = path.join(stateDir, "sync-journal.acme.json");
+        const staleHash = "stale-hash-for-old-content";
+        seedJournalAt(journalPath, {
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files: {
+                "test.md": {
+                    hash: staleHash,
+                    size: 5,
+                    syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                    direction: "up",
+                    remoteEtag: "old-etag",
+                },
+            },
+        });
+        vi.mocked(uploadFile).mockReset();
+        let putAttempted = false;
+        vi.mocked(uploadFile).mockImplementationOnce(async (_ctx, _localPath, key) => {
+            expect(key).toBe("test.md");
+            putAttempted = true;
+            throw new Error("S3 boom");
+        });
+        try {
+            const events = [];
+            const result = await share({
+                paths: [testFile],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+            });
+            expect(putAttempted).toBe(true);
+            expect(result.filesUploaded).toBe(0);
+            expect(journalAt(journalPath).files["test.md"]).toMatchObject({
+                hash: staleHash,
+                remoteEtag: "old-etag",
+            });
+            const errorEvents = events.filter((e) => e.type === "error");
+            expect(errorEvents).toHaveLength(1);
+            expect(errorEvents[0]).toMatchObject({
+                type: "error",
+                path: "test.md",
+                message: expect.stringContaining("S3 boom"),
+            });
+            expect(errorEvents[0]).not.toHaveProperty("diagnostic");
+        }
+        finally {
+            vi.mocked(uploadFile).mockReset();
+            vi.mocked(uploadFile).mockResolvedValue({ etag: '"upload-etag"' });
+        }
+    });
     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 });
@@ -5505,6 +5625,123 @@ describe("share", () => {
         const journal = journalAt(journalPath);
         expect(journal.files["flaky.md"]).toBeDefined();
     });
+    it("defers a rate-limited remote delete as a diagnostic error and leaves the journal row unchanged", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const journalPath = path.join(stateDir, "sync-journal.acme.json");
+        seedJournalAt(journalPath, ({
+            version: "1",
+            lastSync: new Date().toISOString(),
+            files: {
+                "flaky.md": {
+                    hash: "h",
+                    size: 5,
+                    syncedAt: new Date().toISOString(),
+                    direction: "up",
+                    remoteEtag: "flaky-etag",
+                    kind: "file",
+                    localDeleteIntent: deleteIntent("flaky-etag", "h"),
+                },
+            },
+        }));
+        vi.mocked(deleteRemoteFile).mockReset();
+        let deleteAttempted = false;
+        vi.mocked(deleteRemoteFile).mockImplementationOnce(async (_ctx, key) => {
+            expect(key).toBe("flaky.md");
+            deleteAttempted = true;
+            throw new RateLimitedError("flaky.md", "delete");
+        });
+        try {
+            const events = [];
+            const result = await share({
+                paths: [companyRoot],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                propagateDeletes: true,
+                propagateDeletePolicy: "owned-only",
+                onEvent: (e) => events.push(e),
+            });
+            expect(deleteAttempted).toBe(true);
+            expect(result.filesDeleted).toBe(0);
+            expect(journalAt(journalPath).files["flaky.md"]).toBeDefined();
+            expect(result.pathResults).toContainEqual({
+                path: "flaky.md",
+                status: "refused",
+                operation: "delete",
+                reason: "transfer-error",
+            });
+            const errorEvents = events.filter((e) => e.type === "error");
+            expect(errorEvents).toHaveLength(1);
+            expect(errorEvents[0]).toMatchObject({
+                type: "error",
+                diagnostic: true,
+                path: "flaky.md",
+                message: expect.stringMatching(/RateLimited.*delete flaky.md deferred to next sync/),
+            });
+            expect(events.some((e) => e.type === "error" && e.diagnostic !== true)).toBe(false);
+        }
+        finally {
+            vi.mocked(deleteRemoteFile).mockReset();
+            vi.mocked(deleteRemoteFile).mockResolvedValue(undefined);
+        }
+    });
+    it("still emits a hard error when remote delete throws a generic Error", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const journalPath = path.join(stateDir, "sync-journal.acme.json");
+        seedJournalAt(journalPath, ({
+            version: "1",
+            lastSync: new Date().toISOString(),
+            files: {
+                "flaky.md": {
+                    hash: "h",
+                    size: 5,
+                    syncedAt: new Date().toISOString(),
+                    direction: "up",
+                    remoteEtag: "flaky-etag",
+                    kind: "file",
+                    localDeleteIntent: deleteIntent("flaky-etag", "h"),
+                },
+            },
+        }));
+        vi.mocked(deleteRemoteFile).mockReset();
+        let deleteAttempted = false;
+        vi.mocked(deleteRemoteFile).mockImplementationOnce(async (_ctx, key) => {
+            expect(key).toBe("flaky.md");
+            deleteAttempted = true;
+            throw new Error("S3 down");
+        });
+        try {
+            const events = [];
+            const result = await share({
+                paths: [companyRoot],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                propagateDeletes: true,
+                propagateDeletePolicy: "owned-only",
+                onEvent: (e) => events.push(e),
+            });
+            expect(deleteAttempted).toBe(true);
+            expect(result.filesDeleted).toBe(0);
+            expect(journalAt(journalPath).files["flaky.md"]).toBeDefined();
+            const errorEvents = events.filter((e) => e.type === "error");
+            expect(errorEvents).toHaveLength(1);
+            expect(errorEvents[0]).toMatchObject({
+                type: "error",
+                path: "flaky.md",
+                message: expect.stringContaining("S3 down"),
+            });
+            expect(errorEvents[0]).not.toHaveProperty("diagnostic");
+        }
+        finally {
+            vi.mocked(deleteRemoteFile).mockReset();
+            vi.mocked(deleteRemoteFile).mockResolvedValue(undefined);
+        }
+    });
     it("scoped push defense-in-depth: a 403 on DeleteObject of a nested session-log key skips as scope-excluded without an error event", async () => {
         const companyRoot = path.join(tmpDir, "companies", "acme");
         fs.mkdirSync(companyRoot, { recursive: true });