pushwork 1.1.2 → 1.1.4

package/src/core/sync-engine.ts

@@ -266,7 +266,7 @@ export class SyncEngine {
 			const plainUrl = getPlainUrl(entry.url)
 			if (!failedUrls.has(plainUrl)) continue
 
-			debug(`recreate: recreating document for ${filePath} (${plainUrl.slice(0, 20)}...)`)
+			debug(`recreate: recreating document for ${filePath} (${plainUrl})`)
 			out.taskLine(`Recreating document for ${filePath}`)
 
 			try {
@@ -335,7 +335,7 @@ export class SyncEngine {
 				newHandles.push(newHandle)
 				newHandles.push(dirHandle)
 
-				debug(`recreate: created new doc for ${filePath} -> ${newHandle.url.slice(0, 20)}...`)
+				debug(`recreate: created new doc for ${filePath} -> ${newHandle.url}`)
 			} catch (error) {
 				debug(`recreate: failed for ${filePath}: ${error}`)
 				out.taskLine(`Failed to recreate ${filePath}: ${error}`, true)
@@ -378,7 +378,7 @@ export class SyncEngine {
 				(await this.snapshotManager.load()) ||
 				this.snapshotManager.createEmpty()
 
-			debug(`sync: rootDirectoryUrl=${snapshot.rootDirectoryUrl?.slice(0, 30)}..., files=${snapshot.files.size}, dirs=${snapshot.directories.size}`)
+			debug(`sync: rootDirectoryUrl=${snapshot.rootDirectoryUrl}, files=${snapshot.files.size}, dirs=${snapshot.directories.size}`)
 
 			// Wait for initial sync to receive any pending remote changes
 			if (this.config.sync_enabled && snapshot.rootDirectoryUrl) {
@@ -433,6 +433,8 @@ export class SyncEngine {
 			// Detect all changes
 			debug("sync: detecting changes")
 			out.update("Detecting local and remote changes")
+			// Capture pre-push snapshot file paths to detect deletions after push
+			const prePushFilePaths = new Set(snapshot.files.keys())
 			const changes = await this.changeDetector.detectChanges(snapshot)
 
 			// Detect moves
@@ -560,8 +562,18 @@ export class SyncEngine {
 			}
 
 			// Re-detect changes after network sync for fresh state
+			// Compute paths deleted during push so they aren't resurrected during pull
+			const deletedPaths = new Set<string>()
+			for (const p of prePushFilePaths) {
+				if (!snapshot.files.has(p)) {
+					deletedPaths.add(p)
+				}
+			}
+			if (deletedPaths.size > 0) {
+				debug(`sync: excluding ${deletedPaths.size} deleted paths from re-detection`)
+			}
 			debug("sync: re-detecting changes after network sync")
-			const freshChanges = await this.changeDetector.detectChanges(snapshot)
+			const freshChanges = await this.changeDetector.detectChanges(snapshot, deletedPaths)
 			const freshRemoteChanges = freshChanges.filter(
 				c =>
 					c.changeType === ChangeType.REMOTE_ONLY ||
@@ -805,7 +817,7 @@ export class SyncEngine {
 								}
 							)
 							result.filesChanged++
-							debug(`push: created ${change.path} -> ${handle.url.slice(0, 20)}...`)
+							debug(`push: created ${change.path} -> ${handle.url}`)
 						}
 					} else {
 						// Update existing file
@@ -966,6 +978,11 @@ export class SyncEngine {
 		if (snapshotEntry) {
 			// Update existing entry
 			snapshotEntry.head = change.remoteHead
+			// If the remote document was replaced (new URL), update the snapshot URL
+			if (change.remoteUrl) {
+				const fileHandle = await this.repo.find<FileDocument>(change.remoteUrl)
+				snapshotEntry.url = this.getEntryUrl(fileHandle, change.path)
+			}
 		} else {
 			// Create new snapshot entry for newly discovered remote file
 			// We need to find the remote file's URL from the directory hierarchy

package/src/types/documents.ts

@@ -41,7 +41,7 @@ export interface FileDocument {
 export enum FileType {
 	TEXT = "text",
 	BINARY = "binary",
-	DIRECTORY = "directory",
+	DIRECTORY = "directory"
 }
 
 /**
@@ -51,7 +51,7 @@ export enum ChangeType {
 	NO_CHANGE = "no_change",
 	LOCAL_ONLY = "local_only",
 	REMOTE_ONLY = "remote_only",
-	BOTH_CHANGED = "both_changed",
+	BOTH_CHANGED = "both_changed"
 }
 
 /**
@@ -86,4 +86,6 @@ export interface DetectedChange {
 	remoteContent: string | Uint8Array | null
 	localHead?: UrlHeads
 	remoteHead?: UrlHeads
+	/** New remote URL when the remote document was replaced (artifact URL change) */
+	remoteUrl?: AutomergeUrl
 }

package/src/utils/network-sync.ts

@@ -88,7 +88,7 @@ export async function waitForBidirectionalSync(
         const changedDocs: string[] = [];
         for (const [url, heads] of currentHeads) {
           if (lastSeenHeads.get(url) !== heads) {
-            changedDocs.push(url.slice(0, 20) + "...");
+            changedDocs.push(url);
           }
         }
         const newDocs = currentHeads.size - lastSeenHeads.size;
@@ -236,13 +236,13 @@ function waitForHandleSync(
     };
 
     const onConverged = () => {
-      debug(`waitForSync: ${handle.url.slice(0, 20)}... converged in ${Date.now() - startTime}ms`);
+      debug(`waitForSync: ${handle.url}... converged in ${Date.now() - startTime}ms`);
       cleanup();
       resolve(handle);
     };
 
     const timeout = setTimeout(() => {
-      debug(`waitForSync: ${handle.url.slice(0, 20)}... timed out after ${timeoutMs}ms`);
+      debug(`waitForSync: ${handle.url}... timed out after ${timeoutMs}ms`);
       cleanup();
       reject(handle);
     }, timeoutMs);
@@ -317,9 +317,9 @@ export async function waitForSync(
     const remoteHeads = syncInfo?.lastHeads;
     if (A.equals(heads, remoteHeads)) {
       alreadySynced++;
-      debug(`waitForSync: ${handle.url.slice(0, 20)}... already synced`);
+      debug(`waitForSync: ${handle.url}... already synced`);
     } else {
-      debug(`waitForSync: ${handle.url.slice(0, 20)}... needs sync (remoteHeads=${remoteHeads ? 'present' : 'missing'})`);
+      debug(`waitForSync: ${handle.url}... needs sync (remoteHeads=${remoteHeads ? 'present' : 'missing'})`);
       needsSync.push(handle);
     }
   }

package/test/integration/in-memory-sync.test.ts

@@ -583,6 +583,207 @@ describe("Sync Reliability Tests", () => {
       await pushwork(["sync"], repoA);
       expect(await pathExists(path.join(repoA, "parent", "child", "target.txt"))).toBe(false);
     }, 60000);
+
+    it("deleted file in root directory should not resurrect", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.writeFile(path.join(repoA, "root-file.txt"), "root content");
+      await fs.writeFile(path.join(repoA, "keep.txt"), "keep this");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Delete file in root
+      await fs.unlink(path.join(repoA, "root-file.txt"));
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "root-file.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "keep.txt"))).toBe(true);
+
+      // Sync again - should NOT come back
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "root-file.txt"))).toBe(false);
+    }, 60000);
+
+    it("deleted file in non-artifact subdirectory (src/) should not resurrect", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "src"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "src", "index.ts"), "export default 1");
+      await fs.writeFile(path.join(repoA, "src", "helper.ts"), "export function help() {}");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Delete one file in src/
+      await fs.unlink(path.join(repoA, "src", "helper.ts"));
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "src", "helper.ts"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "src", "index.ts"))).toBe(true);
+
+      // Sync again - should NOT come back
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "src", "helper.ts"))).toBe(false);
+    }, 60000);
+
+    it("deleted files should not resurrect after multiple sync cycles", async () => {
+      // Simulate real-world usage: multiple syncs over time with deletions
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "src"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "readme.txt"), "readme");
+      await fs.writeFile(path.join(repoA, "src", "app.ts"), "app");
+      await fs.writeFile(path.join(repoA, "src", "old.ts"), "old");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Cycle 1: delete root file
+      await fs.unlink(path.join(repoA, "readme.txt"));
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "readme.txt"))).toBe(false);
+
+      // Cycle 2: delete src file
+      await fs.unlink(path.join(repoA, "src", "old.ts"));
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "src", "old.ts"))).toBe(false);
+
+      // Cycle 3: just sync - nothing should come back
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "readme.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "src", "old.ts"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "src", "app.ts"))).toBe(true);
+    }, 90000);
+
+    it("peer B should not see files deleted by peer A (root)", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.writeFile(path.join(repoA, "keep.txt"), "keep");
+      await fs.writeFile(path.join(repoA, "delete-me.txt"), "gone");
+      await pushwork(["init", "."], repoA);
+
+      // Clone to B and converge
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      expect(await pathExists(path.join(repoB, "delete-me.txt"))).toBe(true);
+
+      // A deletes a root file
+      await fs.unlink(path.join(repoA, "delete-me.txt"));
+      await pushwork(["sync"], repoA);
+
+      // B syncs - should see the deletion
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "delete-me.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoB, "keep.txt"))).toBe(true);
+
+      // B syncs again - should stay deleted
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "delete-me.txt"))).toBe(false);
+    }, 90000);
+
+    it("peer B should not see files deleted by peer A (src/)", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.mkdir(path.join(repoA, "src"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "src", "index.ts"), "export default 1");
+      await fs.writeFile(path.join(repoA, "src", "old.ts"), "old code");
+      await pushwork(["init", "."], repoA);
+
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      expect(await pathExists(path.join(repoB, "src", "old.ts"))).toBe(true);
+
+      // A deletes a file in src/
+      await fs.unlink(path.join(repoA, "src", "old.ts"));
+      await pushwork(["sync"], repoA);
+
+      // B syncs - should see the deletion
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "src", "old.ts"))).toBe(false);
+      expect(await pathExists(path.join(repoB, "src", "index.ts"))).toBe(true);
+
+      // B syncs again - should stay deleted
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "src", "old.ts"))).toBe(false);
+    }, 90000);
+
+    it("peer B should not see files deleted by peer A (dist/)", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.mkdir(path.join(repoA, "dist", "assets"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "dist", "index.js"), "// index");
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app-ABC.js"), "// build 1");
+      await pushwork(["init", "."], repoA);
+
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-ABC.js"))).toBe(true);
+
+      // A rebuilds: delete old artifact, create new one
+      await fs.unlink(path.join(repoA, "dist", "assets", "app-ABC.js"));
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app-XYZ.js"), "// build 2");
+      await pushwork(["sync"], repoA);
+
+      // A should not have resurrected
+      expect(await pathExists(path.join(repoA, "dist", "assets", "app-ABC.js"))).toBe(false);
+
+      // B syncs - should see new file, NOT old file
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-ABC.js"))).toBe(false);
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-XYZ.js"))).toBe(true);
+
+      // B syncs again - old file should stay gone
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-ABC.js"))).toBe(false);
+    }, 90000);
+
+    it("peer B should see artifact file content update after URL replacement", async () => {
+      // When peer A modifies an artifact file, the document is replaced entirely
+      // (new Automerge doc with a new URL). Peer B's snapshot still points to the
+      // old (now orphaned) URL. detectRemoteChanges sees no head change on the old
+      // doc, and detectNewRemoteDocuments skips paths already in the snapshot.
+      // Without URL replacement detection, B never sees the update.
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.mkdir(path.join(repoA, "dist"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "dist", "app.js"), "// version 1");
+      await pushwork(["init", "."], repoA);
+
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      const bContentV1 = await fs.readFile(path.join(repoB, "dist", "app.js"), "utf-8");
+      expect(bContentV1).toBe("// version 1");
+
+      // A modifies the artifact file — this triggers nuclear replacement (new URL)
+      await fs.writeFile(path.join(repoA, "dist", "app.js"), "// version 2");
+      await pushwork(["sync"], repoA);
+
+      // B syncs — should pick up the new content despite the URL change
+      await pushwork(["sync"], repoB);
+      const bContentV2 = await fs.readFile(path.join(repoB, "dist", "app.js"), "utf-8");
+      expect(bContentV2).toBe("// version 2");
+    }, 90000);
   });
 
   describe("Move/Rename Detection", () => {