@indigoai-us/hq-cloud 6.15.36 → 6.15.37

package/dist/cli/share.test.js

@@ -52,7 +52,7 @@ vi.mock("readline", () => ({
     })),
 }));
 import * as readline from "readline";
-import { share, isForbiddenCompanyVaultKey, UnreachablePushPathsError, currentUploadBytes, _testing as shareTesting } from "./share.js";
+import { share, isForbiddenCompanyVaultKey, ServerOwnedPushPathsError, UnreachablePushPathsError, currentUploadBytes, _testing as shareTesting } from "./share.js";
 import { deleteRemoteFile, downloadFile, headRemoteFile, primeObjectTransport, primeUploads, uploadFile, uploadSymlink, WindowsSymlinkPrivilegeError, } from "../s3.js";
 import { VaultAuthError } from "../vault-client.js";
 import { hashFile, readJournal, writeJournal } from "../journal.js";
@@ -956,8 +956,8 @@ describe("share", () => {
     // no-journal) still uploads. Differential proof: reverting the consult in
     // share.ts makes the first test fail (uploadFile IS called → resurrection).
     describe("push-side tombstone consult", () => {
-        function seedJournal(key, hash, size) {
-            seedJournalAt(path.join(stateDir, "sync-journal.acme.json"), ({
+        function seedJournal(key, hash, size, slug = "acme") {
+            seedJournalAt(path.join(stateDir, `sync-journal.${slug}.json`), ({
                 version: "1",
                 lastSync: new Date().toISOString(),
                 files: {
@@ -1088,6 +1088,71 @@ describe("share", () => {
             expect(uploadFile).not.toHaveBeenCalled();
             expect(result.filesSuppressedByTombstone).toBe(1);
         });
+        it("personal push uses personal=1 to suppress a stale copy, then uploads a real edit", async () => {
+            const f = path.join(tmpDir, "docs", "shared.md");
+            fs.mkdirSync(path.dirname(f), { recursive: true });
+            fs.writeFileSync(f, "shared content");
+            seedJournal("docs/shared.md", hashFile(f), 14, "personal");
+            const deletedAt = new Date().toISOString();
+            const fetchMock = vi.fn().mockImplementation(async (url) => {
+                const u = String(url);
+                if (u.includes("/entity/check-slug/me")) {
+                    return {
+                        ok: true,
+                        status: 200,
+                        json: async () => ({ available: false, conflictingCompanyUid: mockEntity.uid }),
+                        text: async () => "",
+                    };
+                }
+                if (u.includes("/entity/by-slug/") || /\/entity\/cmp_/.test(u)) {
+                    return { ok: true, status: 200, json: async () => ({ entity: mockEntity }), text: async () => "" };
+                }
+                if (u.includes("/sts/vend")) {
+                    return { ok: true, status: 200, json: async () => mockVendResponse, text: async () => "" };
+                }
+                if (u.includes("/v1/files/tombstones")) {
+                    return {
+                        ok: true,
+                        status: 200,
+                        json: async () => ({
+                            tombstones: [{ key: "docs/shared.md", deletedAt }],
+                        }),
+                        text: async () => "",
+                    };
+                }
+                return { ok: false, status: 404, text: async () => "Not found" };
+            });
+            vi.stubGlobal("fetch", fetchMock);
+            const stale = await share({
+                paths: [path.dirname(f)],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                personalMode: true,
+                journalSlug: "personal",
+            });
+            expect(stale.filesSuppressedByTombstone).toBe(1);
+            expect(uploadFile).not.toHaveBeenCalled();
+            const tombstoneUrls = fetchMock.mock.calls
+                .map((call) => String(call[0]))
+                .filter((url) => url.includes("/v1/files/tombstones"));
+            expect(tombstoneUrls).toEqual([
+                "https://vault-api.test/v1/files/tombstones?personal=1",
+            ]);
+            fs.writeFileSync(f, "edited after deletion");
+            vi.mocked(uploadFile).mockClear();
+            const recreated = await share({
+                paths: [path.dirname(f)],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                personalMode: true,
+                journalSlug: "personal",
+            });
+            expect(recreated.filesSuppressedByTombstone).toBe(0);
+            expect(recreated.filesUploaded).toBe(1);
+            expect(uploadFile).toHaveBeenCalledWith(expect.anything(), f, "docs/shared.md", undefined, expect.anything());
+        });
     });
     it("populates conflictPaths and emits a conflict event when both local and remote drifted from journal", async () => {
         const companyRoot = path.join(tmpDir, "companies", "acme");
@@ -1157,6 +1222,110 @@ describe("share", () => {
         expect(fs.readFileSync(path.join(tmpDir, index.conflicts[0].conflictPath), "utf-8"))
             .toBe("local edit");
     });
+    it.each([
+        ["local-only", false],
+        ["divergent-remote", true],
+    ])("direct source push (%s): emits a machine-readable refusal and fails when it is the only requested path", async (_state, divergentRemote) => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        const testFile = path.join(companyRoot, "sources", "meetings", "m-1.md");
+        fs.mkdirSync(path.dirname(testFile), { recursive: true });
+        fs.writeFileSync(testFile, "local meeting source");
+        if (divergentRemote) {
+            seedJournalAt(path.join(stateDir, "sync-journal.acme.json"), {
+                version: "1",
+                lastSync: new Date().toISOString(),
+                files: {
+                    "sources/meetings/m-1.md": {
+                        hash: "remote-body-hash",
+                        size: 21,
+                        syncedAt: new Date().toISOString(),
+                        direction: "down",
+                        remoteEtag: "remote-etag",
+                        localDiverges: true,
+                    },
+                },
+            });
+        }
+        const events = [];
+        await expect(share({
+            paths: [testFile],
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            skipUnchanged: divergentRemote,
+            onEvent: (event) => events.push(event),
+        })).rejects.toMatchObject({
+            name: "ServerOwnedPushPathsError",
+            paths: ["sources/meetings/m-1.md"],
+        });
+        expect(events).toContainEqual({
+            type: "push-refused-server-owned",
+            path: "sources/meetings/m-1.md",
+            nextStep: "use-source-ingestion",
+        });
+        expect(events.some((event) => event.type === "reconciled")).toBe(false);
+        expect(uploadFile).not.toHaveBeenCalled();
+        expect(headRemoteFile).not.toHaveBeenCalled();
+    });
+    it.each([
+        ["local-only", false],
+        ["divergent-remote", true],
+    ])("watch-driven source push (%s): explicit skip mode refuses without failing the pass", async (_state, divergentRemote) => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        const testFile = path.join(companyRoot, "sources", "meetings", "m-2.md");
+        fs.mkdirSync(path.dirname(testFile), { recursive: true });
+        fs.writeFileSync(testFile, "local meeting source");
+        if (divergentRemote) {
+            seedJournalAt(path.join(stateDir, "sync-journal.acme.json"), {
+                version: "1",
+                lastSync: new Date().toISOString(),
+                files: {
+                    "sources/meetings/m-2.md": {
+                        hash: "remote-body-hash",
+                        size: 21,
+                        syncedAt: new Date().toISOString(),
+                        direction: "down",
+                        remoteEtag: "remote-etag",
+                        localDiverges: true,
+                    },
+                },
+            });
+        }
+        const events = [];
+        const result = await share({
+            paths: [testFile],
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            skipUnchanged: true,
+            serverOwnedPathPolicy: "skip",
+            onEvent: (event) => events.push(event),
+        });
+        expect(result).toMatchObject({ filesUploaded: 0, filesSkipped: 1 });
+        expect(events).toContainEqual({
+            type: "push-refused-server-owned",
+            path: "sources/meetings/m-2.md",
+            nextStep: "use-source-ingestion",
+        });
+        expect(events.some((event) => event.type === "reconciled")).toBe(false);
+        expect(uploadFile).not.toHaveBeenCalled();
+        expect(headRemoteFile).not.toHaveBeenCalled();
+    });
+    it("direct source push explains the server-owned refusal and supported next step", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        const testFile = path.join(companyRoot, "sources", "meetings", "m-3.md");
+        fs.mkdirSync(path.dirname(testFile), { recursive: true });
+        fs.writeFileSync(testFile, "local meeting source");
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+        await expect(share({
+            paths: [testFile],
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+        })).rejects.toThrow(ServerOwnedPushPathsError);
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("is server-owned and was not uploaded"));
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("supported integration or ingestion flow"));
+    });
     it("cloud-authoritative: never pushes a stale local ontology/.last-run over the server value (one-sided-change clobber guard)", async () => {
         // Regression for the gardener watermark clobber. A second HQ root sharing this
         // machine's sync journal can leave the local mirror holding a STALE value A while
@@ -1190,11 +1359,14 @@ describe("share", () => {
                 },
             },
         }));
+        const events = [];
         const result = await share({
             paths: [testFile],
             company: "acme",
             vaultConfig: mockConfig,
             hqRoot: tmpDir,
+            serverOwnedPathPolicy: "skip",
+            onEvent: (event) => events.push(event),
         });
         // Server-owned file: push is skipped BEFORE HEAD, the stale local value is NEVER
         // uploaded (the pull leg refreshes local from cloud instead), and it is not a conflict.
@@ -1203,6 +1375,12 @@ describe("share", () => {
         expect(result.filesUploaded).toBe(0);
         expect(result.filesSkipped).toBeGreaterThanOrEqual(1);
         expect(result.conflictPaths).toEqual([]);
+        expect(events).toContainEqual({
+            type: "push-refused-server-owned",
+            path: "ontology/.last-run",
+            nextStep: "change-upstream-and-pull",
+        });
+        expect(events.some((event) => event.type === "reconciled")).toBe(false);
     });
     it("first-time-upload-with-cloud-collision: emits conflict + writes mirror under --on-conflict keep (Bug #7)", async () => {
         // Bug #7 (data-loss class) from the 5.33.0 deep test: when a file has