@indigoai-us/hq-cloud 6.14.18 → 6.14.19

package/dist/bin/sync-runner.test.js

@@ -12,9 +12,9 @@ import * as os from "os";
 import * as path from "path";
 import { runRunner, runRunnerWithLoop, resolveDeletePolicy, resolveSkipPersonal, selectObjectIOFactory, routeChangeToTarget, buildTargetedPushArgv, resolvePullScope, readPinnedPrefixes, SESSIONS_SCOPE_PREFIX, defaultCollectTelemetry, AUTH_REQUIRED_PASS_EXIT, } from "./sync-runner.js";
 import { PresignObjectIO, S3SdkObjectIO } from "../object-io.js";
-import { FakeClock } from "../watcher.js";
-import { adaptivePollMs } from "./sync-runner-watch-loop.js";
-import { PERSONAL_VAULT_JOURNAL_SLUG } from "../journal.js";
+import { FakeClock, } from "../watcher.js";
+import { adaptivePollMs, journalEntriesForWatcherDelete, } from "./sync-runner-watch-loop.js";
+import { PERSONAL_VAULT_JOURNAL_SLUG, readJournal, writeJournal, } from "../journal.js";
 import { HQ_CLOUD_VERSION } from "../version.js";
 import { lockPathFor, OPERATION_LOCKED_EXIT } from "../operation-lock.js";
 import { TRANSIENT_NETWORK_EXIT } from "../lib/net-errors.js";
@@ -154,6 +154,9 @@ function makeDeps(overrides = {}) {
             updated: true,
             embedded: false,
             pendingDirty: false,
+            lockBusy: false,
+            timedOut: false,
+            corruptionQuarantined: false,
         })),
         reconcileManifest: vi
             .fn()
@@ -1800,6 +1803,9 @@ describe("all-complete aggregate", () => {
             updated: true,
             embedded: false,
             pendingDirty: false,
+            lockBusy: false,
+            timedOut: false,
+            corruptionQuarantined: false,
         }));
         const deps = makeDeps({
             createVaultClient: () => makeVaultStub({
@@ -4656,6 +4662,90 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         shutdown();
         await loop;
     });
+    it("does not publish an exit-zero deletion that the scoped push refused", async () => {
+        const publishBatch = vi.fn();
+        const startEventSync = vi.fn().mockResolvedValue({
+            publishBatch,
+            receiver: { start: async () => { }, dispose: async () => { }, connected: true },
+            ownDeviceId: "dev-test",
+            dispose: vi.fn().mockResolvedValue(undefined),
+        });
+        const runPass = vi
+            .fn()
+            .mockResolvedValueOnce(0)
+            .mockResolvedValueOnce({
+            exitCode: 0,
+            result: {
+                pushPathResults: [{
+                        relativePath: "companies/indigo/deleted.md",
+                        status: "refused",
+                        operation: "delete",
+                        reason: "missing-delete-intent",
+                    }],
+            },
+        })
+            .mockResolvedValue(0);
+        const { loop, watcher, tick, shutdown } = runLoop({
+            claims: ENROLLED_CLAIMS,
+            startEventSync,
+            runPass,
+        });
+        await microtasks();
+        watcher.emit("companies/indigo/deleted.md", {
+            paths: new Map([[
+                    "/tmp/hq/companies/indigo/deleted.md",
+                    "companies/indigo/deleted.md",
+                ]]),
+        });
+        tick();
+        await microtasks();
+        expect(publishBatch).not.toHaveBeenCalled();
+        shutdown();
+        await loop;
+    });
+    it("does not publish unlinkDir when a covered descendant delete was refused", async () => {
+        const publishBatch = vi.fn();
+        const startEventSync = vi.fn().mockResolvedValue({
+            publishBatch,
+            receiver: { start: async () => { }, dispose: async () => { }, connected: true },
+            ownDeviceId: "dev-test",
+            dispose: vi.fn().mockResolvedValue(undefined),
+        });
+        const runPass = vi
+            .fn()
+            .mockResolvedValueOnce(0)
+            .mockResolvedValueOnce({
+            exitCode: 0,
+            result: {
+                pushPathResults: [{
+                        relativePath: "companies/indigo/archive/deleted.md",
+                        status: "refused",
+                        operation: "delete",
+                        reason: "missing-delete-intent",
+                    }],
+            },
+        })
+            .mockResolvedValue(0);
+        const { loop, watcher, tick, shutdown } = runLoop({
+            claims: ENROLLED_CLAIMS,
+            startEventSync,
+            runPass,
+        });
+        await microtasks();
+        const absolutePath = "/tmp/hq/companies/indigo/archive";
+        watcher.emit("companies/indigo/archive", {
+            paths: new Map([[
+                    absolutePath,
+                    "companies/indigo/archive",
+                ]]),
+            changes: new Map([[absolutePath, { kind: "unlinkDir" }]]),
+        });
+        tick();
+        await microtasks();
+        expect(publishBatch).not.toHaveBeenCalled();
+        shutdown();
+        await loop;
+    });
     it("F04: mixed-route watcher batches publish only routes that were pushed", async () => {
         const publishBatch = vi.fn();
         const startEventSync = vi.fn().mockResolvedValue({
@@ -5694,4 +5784,406 @@ describe("US-002 — manifest reconciliation wiring", () => {
         expect(deps.stderr.raw()).not.toContain("manifest-reconciled");
     });
 });
+describe("watcher delete intents without pre-seeded authorization", () => {
+    function startDeleteHarness(keys, options = {}) {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-watch-delete-"));
+        const companyRoot = path.join(hqRoot, "companies", "indigo");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const remote = new Map();
+        const files = {};
+        for (const key of keys) {
+            const absolutePath = path.join(companyRoot, key);
+            const content = `synced:${key}`;
+            fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+            fs.writeFileSync(absolutePath, content);
+            remote.set(key, content);
+            files[key] = {
+                hash: `hash:${key}`,
+                size: Buffer.byteLength(content),
+                syncedAt: new Date().toISOString(),
+                direction: "down",
+                remoteEtag: `etag:${key}`,
+                kind: "file",
+            };
+        }
+        writeJournal("indigo", {
+            version: "2", lastSync: new Date().toISOString(), files, pulls: [],
+        });
+        const watcher = makeBatchWatcherStub();
+        const sleep = makeSteppableSleep();
+        let capture;
+        let triggerShutdown = () => { };
+        let downloads = 0;
+        let releaseInitialPull = () => { };
+        const initialPullGate = new Promise((resolve) => {
+            releaseInitialPull = resolve;
+        });
+        let initialPullGated = options.gateInitialPull === true;
+        const runPass = vi.fn(async (argv) => {
+            const direction = argv[argv.indexOf("--direction") + 1];
+            if (direction === "push") {
+                const journal = readJournal("indigo");
+                const pathResults = [];
+                const scopes = argv.flatMap((value, index) => argv[index - 1] === "--scope-path" ? [value] : []);
+                for (const scope of scopes) {
+                    for (const key of Object.keys(journal.files)) {
+                        if (key !== scope && !key.startsWith(`${scope}/`))
+                            continue;
+                        const absolutePath = path.join(companyRoot, key);
+                        const entry = journal.files[key];
+                        if (fs.existsSync(absolutePath)) {
+                            remote.set(key, fs.readFileSync(absolutePath, "utf8"));
+                            continue;
+                        }
+                        const intent = entry.localDeleteIntent;
+                        const current = intent?.remoteEtag === entry.remoteEtag &&
+                            intent?.localHash === entry.hash &&
+                            intent?.localKind === entry.kind;
+                        if (current) {
+                            remote.delete(key);
+                            delete journal.files[key];
+                            pathResults.push({
+                                relativePath: `companies/indigo/${key}`,
+                                status: "accepted",
+                                operation: "delete",
+                            });
+                        }
+                        else {
+                            pathResults.push({
+                                relativePath: `companies/indigo/${key}`,
+                                status: "refused",
+                                operation: "delete",
+                                reason: "missing-delete-intent",
+                            });
+                        }
+                    }
+                    const added = path.join(companyRoot, scope);
+                    if (fs.existsSync(added) && fs.lstatSync(added).isFile()) {
+                        remote.set(scope, fs.readFileSync(added, "utf8"));
+                    }
+                }
+                writeJournal("indigo", journal);
+                return { exitCode: 0, result: { pushPathResults: pathResults } };
+            }
+            if (direction === "pull" || direction === "both") {
+                if (initialPullGated) {
+                    initialPullGated = false;
+                    await initialPullGate;
+                }
+                const journal = readJournal("indigo");
+                for (const [key, content] of remote) {
+                    const absolutePath = path.join(companyRoot, key);
+                    if (fs.existsSync(absolutePath))
+                        continue;
+                    const entry = journal.files[key];
+                    const intent = entry?.localDeleteIntent;
+                    const currentIntent = intent?.remoteEtag === entry?.remoteEtag &&
+                        intent?.localHash === entry?.hash &&
+                        intent?.localKind === entry?.kind;
+                    if (currentIntent)
+                        continue;
+                    fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+                    fs.writeFileSync(absolutePath, content);
+                    downloads++;
+                }
+            }
+            return 0;
+        });
+        const loop = runRunnerWithLoop([
+            "--companies", "--watch", "--event-push", "--direction", "both",
+            "--hq-root", hqRoot, "--poll-remote-ms", "60000",
+        ], {
+            runPass,
+            createWatcher: (opts) => {
+                capture = opts.captureLocalDeleteSnapshots;
+                return watcher;
+            },
+            sleep: sleep.sleep,
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        return {
+            hqRoot, companyRoot, remote, watcher, loop, tick: sleep.tick,
+            capture: () => capture, downloads: () => downloads,
+            releaseInitialPull,
+            shutdown: () => triggerShutdown(),
+        };
+    }
+    async function settle() {
+        await flushLoopMicrotasks(12);
+    }
+    async function stopHarness(h) {
+        h.shutdown();
+        h.tick();
+        await h.loop;
+        fs.rmSync(h.hqRoot, { recursive: true, force: true });
+    }
+    it("live unlink binds the pre-delete revision, deletes remote, and survives immediate plus later full pulls", async () => {
+        const h = startDeleteHarness(["knowledge/gone.md"]);
+        await settle();
+        const absolutePath = path.join(h.companyRoot, "knowledge/gone.md");
+        fs.unlinkSync(absolutePath);
+        const snapshots = h.capture()("companies/indigo/knowledge/gone.md", "unlink");
+        expect(snapshots).toHaveLength(1);
+        expect(readJournal("indigo").files["knowledge/gone.md"]?.localDeleteIntent)
+            .toMatchObject({
+            remoteEtag: "etag:knowledge/gone.md",
+            localHash: "hash:knowledge/gone.md",
+            localKind: "file",
+        });
+        h.watcher.emit("companies/indigo/knowledge/gone.md", {
+            paths: new Map([[absolutePath, "companies/indigo/knowledge/gone.md"]]),
+            changes: new Map([
+                [absolutePath, { kind: "unlink", deleteSnapshots: snapshots }],
+            ]),
+        });
+        h.tick();
+        await settle();
+        expect(h.remote.has("knowledge/gone.md")).toBe(false);
+        expect(fs.existsSync(absolutePath)).toBe(false);
+        expect(h.downloads()).toBe(0);
+        for (let i = 0; i < 8; i++) {
+            h.tick();
+            await settle();
+        }
+        expect(fs.existsSync(absolutePath)).toBe(false);
+        expect(h.downloads()).toBe(0);
+        await stopHarness(h);
+    });
+    it("persists the intent before an in-flight pull plans the missing path", async () => {
+        const h = startDeleteHarness(["knowledge/in-flight.md"], { gateInitialPull: true });
+        await settle();
+        const relativePath = "companies/indigo/knowledge/in-flight.md";
+        const absolutePath = path.join(h.companyRoot, "knowledge/in-flight.md");
+        fs.unlinkSync(absolutePath);
+        const snapshots = h.capture()(relativePath, "unlink");
+        expect(snapshots).toHaveLength(1);
+        expect(readJournal("indigo").files["knowledge/in-flight.md"]
+            ?.localDeleteIntent).toBeDefined();
+        h.watcher.emit(relativePath, {
+            paths: new Map([[absolutePath, relativePath]]),
+            changes: new Map([
+                [absolutePath, { kind: "unlink", deleteSnapshots: snapshots }],
+            ]),
+        });
+        h.releaseInitialPull();
+        await settle();
+        expect(h.downloads()).toBe(0);
+        expect(fs.existsSync(absolutePath)).toBe(false);
+        h.tick();
+        await settle();
+        expect(h.remote.has("knowledge/in-flight.md")).toBe(false);
+        expect(h.downloads()).toBe(0);
+        await stopHarness(h);
+    });
+    it("uses direct journal-key lookup for file unlink snapshots", () => {
+        const exactEntry = {
+            hash: "hash",
+            size: 4,
+            syncedAt: new Date().toISOString(),
+            direction: "down",
+            remoteEtag: "etag",
+            kind: "file",
+        };
+        const files = new Proxy({ "knowledge/exact.md": exactEntry }, {
+            ownKeys: () => {
+                throw new Error("file unlink must not enumerate the journal");
+            },
+        });
+        expect(journalEntriesForWatcherDelete(files, "knowledge/exact.md", "unlink")).toEqual([["knowledge/exact.md", exactEntry]]);
+    });
+    it("keeps a deleted top-level personal file in the scoped push delete roots", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-personal-delete-"));
+        const key = "personal-note.md";
+        const absolutePath = path.join(hqRoot, key);
+        fs.writeFileSync(absolutePath, "personal content");
+        const remote = new Map([[key, "personal content"]]);
+        writeJournal(PERSONAL_VAULT_JOURNAL_SLUG, {
+            version: "2",
+            lastSync: new Date().toISOString(),
+            pulls: [],
+            files: {
+                [key]: {
+                    hash: "personal-hash",
+                    size: 16,
+                    syncedAt: new Date().toISOString(),
+                    direction: "down",
+                    remoteEtag: "personal-etag",
+                    kind: "file",
+                },
+            },
+        });
+        const shareSpy = vi.fn(async (options) => {
+            const journal = readJournal(PERSONAL_VAULT_JOURNAL_SLUG);
+            const entry = journal.files[key];
+            const intent = entry?.localDeleteIntent;
+            const currentIntent = intent?.remoteEtag === entry?.remoteEtag &&
+                intent?.localHash === entry?.hash &&
+                intent?.localKind === entry?.kind;
+            if (!fs.existsSync(absolutePath) &&
+                options.deleteScopeRoots?.includes(key) &&
+                currentIntent) {
+                remote.delete(key);
+                delete journal.files[key];
+                writeJournal(PERSONAL_VAULT_JOURNAL_SLUG, journal);
+                return defaultShareResult({
+                    filesDeleted: 1,
+                    pathResults: [
+                        { path: key, status: "accepted", operation: "delete" },
+                    ],
+                });
+            }
+            return defaultShareResult();
+        });
+        let downloads = 0;
+        const syncSpy = vi.fn(async () => {
+            if (remote.has(key) && !fs.existsSync(absolutePath)) {
+                const entry = readJournal(PERSONAL_VAULT_JOURNAL_SLUG).files[key];
+                const intent = entry?.localDeleteIntent;
+                const currentIntent = intent?.remoteEtag === entry?.remoteEtag &&
+                    intent?.localHash === entry?.hash &&
+                    intent?.localKind === entry?.kind;
+                if (!currentIntent) {
+                    fs.writeFileSync(absolutePath, remote.get(key));
+                    downloads++;
+                }
+            }
+            return defaultSyncResult();
+        });
+        const runnerDeps = makeDeps({
+            share: shareSpy,
+            sync: syncSpy,
+            createVaultClient: () => makeVaultStub({
+                listPersons: () => Promise.resolve([
+                    {
+                        uid: "prs_personal",
+                        type: "person",
+                        bucketName: "hq-vault-personal",
+                        status: "active",
+                    },
+                ]),
+            }),
+            operationLockAlreadyHeld: true,
+        });
+        const watcher = makeBatchWatcherStub();
+        const sleep = makeSteppableSleep();
+        let capture;
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop([
+            "--personal",
+            "--watch",
+            "--event-push",
+            "--direction",
+            "both",
+            "--hq-root",
+            hqRoot,
+            "--poll-remote-ms",
+            "60000",
+        ], {
+            runPass: (passArgv) => runRunner(passArgv, runnerDeps),
+            createWatcher: (options) => {
+                capture = options.captureLocalDeleteSnapshots;
+                return watcher;
+            },
+            sleep: sleep.sleep,
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        await vi.waitFor(() => expect(syncSpy).toHaveBeenCalled());
+        await settle();
+        shareSpy.mockClear();
+        fs.unlinkSync(absolutePath);
+        const snapshots = capture(key, "unlink");
+        expect(snapshots).toHaveLength(1);
+        expect(snapshots[0].deleteScopeRoot).toBe(key);
+        expect(readJournal(PERSONAL_VAULT_JOURNAL_SLUG).files[key]
+            ?.localDeleteIntent).toBeDefined();
+        watcher.emit(key, {
+            paths: new Map([[absolutePath, key]]),
+            changes: new Map([
+                [absolutePath, { kind: "unlink", deleteSnapshots: snapshots }],
+            ]),
+        });
+        sleep.tick();
+        await settle();
+        expect(remote.has(key)).toBe(false);
+        expect(downloads).toBe(0);
+        expect(fs.existsSync(absolutePath)).toBe(false);
+        const scopedShareOptions = shareSpy.mock.calls.at(-1)?.[0];
+        expect(scopedShareOptions?.paths).not.toContain(absolutePath);
+        expect(scopedShareOptions?.deleteScopeRoots).toEqual([key]);
+        triggerShutdown();
+        await loop;
+        fs.rmSync(hqRoot, { recursive: true, force: true });
+    });
+    it("rename uploads the new path, deletes the old path, and neither resurrects", async () => {
+        const h = startDeleteHarness(["knowledge/old.md"]);
+        await settle();
+        const oldPath = path.join(h.companyRoot, "knowledge/old.md");
+        const newPath = path.join(h.companyRoot, "knowledge/new.md");
+        const snapshots = h.capture()("companies/indigo/knowledge/old.md", "unlink");
+        fs.renameSync(oldPath, newPath);
+        h.watcher.emit("companies/indigo/knowledge/old.md", {
+            paths: new Map([
+                [oldPath, "companies/indigo/knowledge/old.md"],
+                [newPath, "companies/indigo/knowledge/new.md"],
+            ]),
+            changes: new Map([
+                [oldPath, { kind: "unlink", deleteSnapshots: snapshots }],
+                [newPath, { kind: "add" }],
+            ]),
+        });
+        h.tick();
+        await settle();
+        expect(h.remote.has("knowledge/old.md")).toBe(false);
+        expect(h.remote.get("knowledge/new.md")).toBe("synced:knowledge/old.md");
+        expect(fs.existsSync(oldPath)).toBe(false);
+        expect(fs.existsSync(newPath)).toBe(true);
+        await stopHarness(h);
+    });
+    it("unlinkDir records every tracked descendant across a 12-file breaker-sized subtree", async () => {
+        const keys = Array.from({ length: 12 }, (_, i) => `knowledge/moved/f-${i}.md`);
+        const h = startDeleteHarness(keys);
+        await settle();
+        const subtree = path.join(h.companyRoot, "knowledge/moved");
+        const snapshots = h.capture()("companies/indigo/knowledge/moved", "unlinkDir");
+        expect(snapshots).toHaveLength(12);
+        fs.rmSync(subtree, { recursive: true, force: true });
+        h.watcher.emit("companies/indigo/knowledge/moved", {
+            paths: new Map([[subtree, "companies/indigo/knowledge/moved"]]),
+            changes: new Map([
+                [subtree, { kind: "unlinkDir", deleteSnapshots: snapshots }],
+            ]),
+        });
+        h.tick();
+        await settle();
+        expect(h.remote.size).toBe(0);
+        expect(Object.keys(readJournal("indigo").files)).toHaveLength(0);
+        await stopHarness(h);
+    });
+    it("concurrent recreation before delete execution invalidates the observation and preserves remote", async () => {
+        const h = startDeleteHarness(["knowledge/race.md"]);
+        await settle();
+        const absolutePath = path.join(h.companyRoot, "knowledge/race.md");
+        fs.unlinkSync(absolutePath);
+        const snapshots = h.capture()("companies/indigo/knowledge/race.md", "unlink");
+        h.watcher.emit("companies/indigo/knowledge/race.md", {
+            paths: new Map([[absolutePath, "companies/indigo/knowledge/race.md"]]),
+            changes: new Map([
+                [absolutePath, { kind: "unlink", deleteSnapshots: snapshots }],
+            ]),
+        });
+        fs.writeFileSync(absolutePath, "concurrent recreation");
+        h.tick();
+        await settle();
+        expect(h.remote.has("knowledge/race.md")).toBe(true);
+        expect(readJournal("indigo").files["knowledge/race.md"]?.localDeleteIntent)
+            .toBeUndefined();
+        await stopHarness(h);
+    });
+});
 //# sourceMappingURL=sync-runner.test.js.map