@indigoai-us/hq-cloud 6.16.65 → 6.16.67

package/dist/cli/share.test.js

@@ -64,7 +64,7 @@ vi.mock("readline", () => ({
     })),
 }));
 import * as readline from "readline";
-import { share, ServerOwnedPushPathsError, UnreachablePushPathsError, UnregisteredCompanySkillError, currentUploadBytes, parseRegisteredCompanySkillUid, _testing as shareTesting, } from "./share.js";
+import { share, ServerOwnedPushPathsError, UnreachablePushPathsError, UnregisteredCompanySkillError, currentUploadBytes, FULL_PUSH_COOPERATIVE_CHECKPOINT_BATCH_SIZE, parseRegisteredCompanySkillUid, _testing as shareTesting, } from "./share.js";
 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";
@@ -72,6 +72,7 @@ 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";
+import { CooperativePassScheduler } from "../bin/sync-runner-watch-loop.js";
 /**
  * Read a journal the way production does.
  *
@@ -1658,6 +1659,7 @@ describe("share", () => {
         fs.rmSync(tmpDir, { recursive: true, force: true });
         fs.rmSync(stateDir, { recursive: true, force: true });
         delete process.env.HQ_STATE_DIR;
+        shareTesting.disableCooperativeRowVisits();
     });
     it("shares a single file keyed relative to the company root", async () => {
         const companyRoot = path.join(tmpDir, "companies", "acme");
@@ -1675,6 +1677,285 @@ describe("share", () => {
         // Remote key must be company-relative, not hqRoot-relative
         expect(uploadFile).toHaveBeenCalledWith(expect.anything(), testFile, "test.md", undefined, expect.anything());
     });
+    it("hands queued realtime work a settled full-push boundary without losing journal rows", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        const fileCount = FULL_PUSH_COOPERATIVE_CHECKPOINT_BATCH_SIZE + 1;
+        for (let index = 0; index < fileCount; index++) {
+            const file = path.join(companyRoot, "docs", "full-push", `${index}.md`);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, "full-push body");
+        }
+        const scheduler = new CooperativePassScheduler(() => 0);
+        let uploadsCompleted = 0;
+        let uploadsInFlight = 0;
+        let maxUploadsInFlight = 0;
+        let realtimeQueued = false;
+        let realtimeDispatchedAt = -1;
+        let checkpointCalls = 0;
+        let realtimePass;
+        const upload = vi.mocked(uploadFile);
+        const originalUpload = upload.getMockImplementation();
+        upload.mockImplementation(async () => {
+            uploadsInFlight++;
+            maxUploadsInFlight = Math.max(maxUploadsInFlight, uploadsInFlight);
+            await Promise.resolve();
+            uploadsCompleted++;
+            if (uploadsCompleted === 1) {
+                realtimeQueued = true;
+                realtimePass = scheduler.submit(async () => {
+                    // `executeUploads` drains the full unit before the scheduler grants
+                    // realtime the root lock: no two durable writers overlap.
+                    expect(uploadsInFlight).toBe(0);
+                    realtimeDispatchedAt = uploadsCompleted;
+                    const realtimePath = path.join(companyRoot, "docs", "realtime.md");
+                    fs.writeFileSync(realtimePath, "realtime body");
+                    const journal = readJournal("acme");
+                    journal.files["docs/realtime.md"] = {
+                        hash: hashFile(realtimePath),
+                        size: fs.statSync(realtimePath).size,
+                        syncedAt: "2026-09-17T12:00:00.000Z",
+                        direction: "up",
+                        remoteEtag: "realtime",
+                        mtimeMs: fs.statSync(realtimePath).mtimeMs,
+                        ctimeMs: fs.statSync(realtimePath).ctimeMs,
+                    };
+                    writeJournal("acme", journal);
+                }, "realtime");
+            }
+            uploadsInFlight--;
+            return { etag: '"full-push-etag"' };
+        });
+        try {
+            await scheduler.submit(async ({ checkpoint }) => {
+                await share({
+                    paths: [companyRoot],
+                    company: "acme",
+                    vaultConfig: mockConfig,
+                    hqRoot: tmpDir,
+                    skipUnchanged: true,
+                    propagateDeletes: true,
+                    cooperativeCheckpoint: async () => {
+                        checkpointCalls++;
+                        return checkpoint();
+                    },
+                });
+            }, "chore");
+            await realtimePass;
+        }
+        finally {
+            if (originalUpload)
+                upload.mockImplementation(originalUpload);
+            else
+                upload.mockReset();
+        }
+        expect(maxUploadsInFlight).toBeGreaterThan(1);
+        expect(realtimeQueued).toBe(true);
+        expect(checkpointCalls).toBeGreaterThan(0);
+        expect(realtimeDispatchedAt).toBeGreaterThan(0);
+        expect(realtimeDispatchedAt).toBeLessThanOrEqual(FULL_PUSH_COOPERATIVE_CHECKPOINT_BATCH_SIZE);
+        // Reopen the durable journal, rather than inspecting the stale first-pass
+        // object: every pre-handoff key and the realtime key must survive.
+        const durable = readJournal("acme");
+        expect(Object.keys(durable.files)).toHaveLength(fileCount + 1);
+        expect(durable.files["docs/realtime.md"]).toBeDefined();
+        for (let index = 0; index < fileCount; index++) {
+            expect(durable.files[`docs/full-push/${index}.md`]).toBeDefined();
+        }
+    }, 120_000);
+    it("hands an all-skipped full personal push to queued realtime work", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        const fileCount = FULL_PUSH_COOPERATIVE_CHECKPOINT_BATCH_SIZE + 1;
+        const files = {};
+        for (let index = 0; index < fileCount; index++) {
+            const relativePath = `docs/unchanged/${index}.md`;
+            const file = path.join(companyRoot, relativePath);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, "unchanged body");
+            const stat = fs.statSync(file);
+            files[relativePath] = {
+                hash: hashFile(file),
+                size: stat.size,
+                mtimeMs: stat.mtimeMs,
+                ctimeMs: stat.ctimeMs,
+                syncedAt: "2026-09-17T12:00:00.000Z",
+                direction: "up",
+                remoteEtag: "unchanged",
+            };
+        }
+        seedJournalAt(path.join(stateDir, "sync-journal.acme.json"), {
+            version: "2",
+            lastSync: "2026-09-17T12:00:00.000Z",
+            files,
+            pulls: [],
+        });
+        const scheduler = new CooperativePassScheduler(() => 0);
+        let fullPassFinished = false;
+        let eventLoopTicked = false;
+        let realtimeQueued = false;
+        let realtimeRanBeforeFullPassFinished = false;
+        let checkpointCalls = 0;
+        let realtimePass;
+        let resolveRealtimeScheduled;
+        const realtimeScheduled = new Promise((resolve) => {
+            resolveRealtimeScheduled = resolve;
+        });
+        const queueRealtime = () => {
+            if (realtimeQueued)
+                return;
+            realtimeQueued = true;
+            setImmediate(() => {
+                eventLoopTicked = true;
+                realtimePass = scheduler.submit(async () => {
+                    realtimeRanBeforeFullPassFinished = !fullPassFinished;
+                }, "realtime");
+                resolveRealtimeScheduled?.();
+            });
+        };
+        await scheduler.submit(async ({ checkpoint }) => {
+            try {
+                const result = await share({
+                    paths: [companyRoot],
+                    company: "acme",
+                    vaultConfig: mockConfig,
+                    hqRoot: tmpDir,
+                    skipUnchanged: true,
+                    onEvent: (event) => {
+                        if (event.type === "plan")
+                            queueRealtime();
+                    },
+                    cooperativeCheckpoint: async () => {
+                        checkpointCalls++;
+                        return checkpoint();
+                    },
+                });
+                expect(result.filesSkipped).toBe(fileCount);
+                expect(result.filesUploaded).toBe(0);
+            }
+            finally {
+                fullPassFinished = true;
+            }
+        }, "chore");
+        await realtimeScheduled;
+        await realtimePass;
+        expect(eventLoopTicked).toBe(true);
+        expect(realtimeQueued).toBe(true);
+        expect(realtimeRanBeforeFullPassFinished).toBe(true);
+        expect(checkpointCalls).toBeGreaterThan(0);
+        expect(uploadFile).not.toHaveBeenCalled();
+        expect(Object.keys(readJournal("acme").files)).toHaveLength(fileCount);
+    }, 120_000);
+    it("resumes a skip-only full push at the next unit after realtime hand-off", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        const fileCount = FULL_PUSH_COOPERATIVE_CHECKPOINT_BATCH_SIZE * 3;
+        const files = {};
+        for (let index = 0; index < fileCount; index++) {
+            const relativePath = `docs/resume/${index}.md`;
+            const file = path.join(companyRoot, relativePath);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, "resume body");
+            const stat = fs.statSync(file);
+            files[relativePath] = {
+                hash: hashFile(file),
+                size: stat.size,
+                mtimeMs: stat.mtimeMs,
+                ctimeMs: stat.ctimeMs,
+                syncedAt: "2026-09-17T12:00:00.000Z",
+                direction: "up",
+                remoteEtag: "unchanged",
+            };
+        }
+        seedJournalAt(path.join(stateDir, "sync-journal.acme.json"), {
+            version: "2",
+            lastSync: "2026-09-17T12:00:00.000Z",
+            files,
+            pulls: [],
+        });
+        const scheduler = new CooperativePassScheduler(() => 0);
+        let fullPassFinished = false;
+        let realtimeRanBeforeFullPassFinished = false;
+        const planEvents = [];
+        const realtimePhaseRuns = [];
+        const realtimePasses = [];
+        const queuedForPhase = new Set();
+        let currentPhase = "collection";
+        const queueRealtimeForCurrentPhase = () => {
+            const phase = currentPhase;
+            if (queuedForPhase.has(phase))
+                return;
+            queuedForPhase.add(phase);
+            setImmediate(() => {
+                realtimePasses.push(scheduler.submit(async () => {
+                    realtimePhaseRuns.push(phase);
+                    if (!fullPassFinished)
+                        realtimeRanBeforeFullPassFinished = true;
+                }, "realtime"));
+            });
+        };
+        shareTesting.enableCooperativeRowVisits();
+        let visits = {
+            collect: new Map(),
+            plan: new Map(),
+        };
+        try {
+            await scheduler.submit(async ({ checkpoint }) => {
+                queueRealtimeForCurrentPhase();
+                try {
+                    const result = await share({
+                        paths: [companyRoot],
+                        company: "acme",
+                        vaultConfig: mockConfig,
+                        hqRoot: tmpDir,
+                        skipUnchanged: true,
+                        propagateDeletes: true,
+                        onEvent: (event) => {
+                            if (event.type === "plan") {
+                                planEvents.push(event);
+                                currentPhase = "execution";
+                                queueRealtimeForCurrentPhase();
+                            }
+                        },
+                        cooperativeCheckpoint: async () => {
+                            if (currentPhase === "collection" &&
+                                shareTesting.cooperativeRowVisits().plan.size > 0) {
+                                currentPhase = "planning";
+                            }
+                            if (currentPhase === "planning")
+                                queueRealtimeForCurrentPhase();
+                            return checkpoint();
+                        },
+                    });
+                    expect(result.filesSkipped).toBe(fileCount);
+                    expect(result.filesUploaded).toBe(0);
+                }
+                finally {
+                    fullPassFinished = true;
+                }
+            }, "chore");
+            await Promise.all(realtimePasses);
+            visits = shareTesting.cooperativeRowVisits();
+        }
+        finally {
+            shareTesting.disableCooperativeRowVisits();
+        }
+        expect(realtimeRanBeforeFullPassFinished).toBe(true);
+        expect(realtimePhaseRuns).toEqual(["collection", "planning", "execution"]);
+        expect(planEvents).toHaveLength(1);
+        expect(planEvents[0]).toMatchObject({
+            type: "plan",
+            filesToUpload: 0,
+            filesToSkip: fileCount,
+            filesToDelete: 0,
+        });
+        expect(visits.collect.size).toBe(fileCount);
+        expect(visits.plan.size).toBe(fileCount);
+        for (let index = 0; index < fileCount; index++) {
+            const relativePath = `docs/resume/${index}.md`;
+            expect(visits.collect.get(relativePath)).toBe(1);
+            expect(visits.plan.get(relativePath)).toBe(1);
+        }
+        expect(uploadFile).not.toHaveBeenCalled();
+        expect(Object.keys(readJournal("acme").files)).toHaveLength(fileCount);
+    }, 120_000);
     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
@@ -1794,6 +2075,61 @@ describe("share", () => {
             vi.mocked(uploadFile).mockResolvedValue({ etag: '"upload-etag"' });
         }
     });
+    it("defers a file that vanishes between upload and journal as a diagnostic error", async () => {
+        // Production (2026-09-19 02:02:57Z, agent Alpha, company equi):
+        // workers/thread-police/data/run.lock was PUT, then deleted by the
+        // worker before updateEntry's lstat. PrematureJournalEntryError is
+        // correct (nothing journaled), but the catch used to emit a hard
+        // type:"error" so hq-sync-runner exited 2. Same diagnostic deferral
+        // as a rate-limited PUT; the next pass re-plans the key.
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const relativePath = "workers/thread-police/data/run.lock";
+        const testFile = path.join(companyRoot, relativePath);
+        fs.mkdirSync(path.dirname(testFile), { recursive: true });
+        fs.writeFileSync(testFile, "pid");
+        const journalPath = path.join(stateDir, "sync-journal.acme.json");
+        seedJournalAt(journalPath, {
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files: {},
+        });
+        vi.mocked(uploadFile).mockReset();
+        let putAttempted = false;
+        vi.mocked(uploadFile).mockImplementationOnce(async (_ctx, localPath, key) => {
+            expect(key).toBe(relativePath);
+            putAttempted = true;
+            fs.unlinkSync(localPath);
+            return { etag: '"upload-etag"' };
+        });
+        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[relativePath]).toBeUndefined();
+            const errorEvents = events.filter((e) => e.type === "error");
+            expect(errorEvents).toHaveLength(1);
+            expect(errorEvents[0]).toMatchObject({
+                type: "error",
+                diagnostic: true,
+                path: relativePath,
+                message: expect.stringContaining("PrematureJournalEntryError"),
+            });
+            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("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
@@ -2085,7 +2421,7 @@ describe("share", () => {
         });
         expect(result.filesUploaded).toBe(2);
     });
-    it("walks a very large directory without using its entries as call arguments", () => {
+    it("walks a very large directory without using its entries as call arguments", async () => {
         const companyRoot = path.join(tmpDir, "companies", "acme");
         fs.mkdirSync(companyRoot, { recursive: true });
         const nestedDir = path.join(companyRoot, "nested");
@@ -2112,8 +2448,15 @@ describe("share", () => {
             .spyOn(fs, "readdirSync")
             .mockImplementation(((dir) => path.resolve(String(dir)) === nestedDir ? nestedEntries : rootEntries));
         let heartbeatCalls = 0;
+        let eventLoopTicked = false;
+        const eventLoopTick = new Promise((resolve) => {
+            setImmediate(() => {
+                eventLoopTicked = true;
+                resolve();
+            });
+        });
         try {
-            const collected = shareTesting.collectFiles([companyRoot], tmpDir, companyRoot, () => true, { onHeartbeat: () => heartbeatCalls++ });
+            const collected = await shareTesting.collectFiles([companyRoot], tmpDir, companyRoot, () => true, { onHeartbeat: () => heartbeatCalls++ });
             expect(collected).toHaveLength(entryCount);
             expect(collected[0]).toMatchObject({ relativePath: "before.md" });
             expect(collected[1]).toMatchObject({ relativePath: "nested/child.md" });
@@ -2122,6 +2465,8 @@ describe("share", () => {
                 relativePath: `entry-${entryCount - 3}.md`,
             });
             expect(heartbeatCalls).toBeGreaterThan(entryCount);
+            expect(eventLoopTicked).toBe(true);
+            await eventLoopTick;
         }
         finally {
             readdirSpy.mockRestore();
@@ -7851,7 +8196,7 @@ describe("share", () => {
             expect(uploadFile).toHaveBeenCalledWith(expect.anything(), realPolicy, "policies/real.md", undefined, expect.anything());
             expect(uploadSymlink).toHaveBeenCalledWith(expect.anything(), "real.md", "policies/link.md", undefined, expect.anything());
         });
-        it("skips and reports a top-level link whose win32 readlink raises EINVAL", () => {
+        it("skips and reports a top-level link whose win32 readlink raises EINVAL", async () => {
             const companyRoot = path.join(tmpDir, "companies", "acme");
             const targetDir = path.join(tmpDir, "outside", "target");
             fs.mkdirSync(targetDir, { recursive: true });
@@ -7870,7 +8215,7 @@ describe("share", () => {
             const warnings = vi.spyOn(console, "error").mockImplementation(() => { });
             const unreachable = [];
             try {
-                const collected = shareTesting.collectFiles([unreadableLink], tmpDir, companyRoot, () => true, {
+                const collected = await shareTesting.collectFiles([unreadableLink], tmpDir, companyRoot, () => true, {
                     onUnreachablePath: (namedPath, reason) => unreachable.push([namedPath, reason]),
                 });
                 expect(collected).toEqual([]);