pushwork 1.0.22 → 1.0.26

package/src/core/sync-engine.ts

@@ -30,7 +30,7 @@ import {
 	updateTextContent,
 	readDocContent,
 } from "../utils"
-import {isContentEqual} from "../utils/content"
+import {isContentEqual, contentHash} from "../utils/content"
 import {waitForSync, waitForBidirectionalSync} from "../utils/network-sync"
 import {SnapshotManager} from "./snapshot"
 import {ChangeDetector} from "./change-detection"
@@ -86,7 +86,8 @@ export class SyncEngine {
 		this.changeDetector = new ChangeDetector(
 			repo,
 			rootPath,
-			config.exclude_patterns
+			config.exclude_patterns,
+			config.artifact_directories || []
 		)
 		this.moveDetector = new MoveDetector(config.sync.move_detection_threshold)
 	}
@@ -249,108 +250,110 @@ export class SyncEngine {
 	}
 
 	/**
-	 * Push local changes to server without pulling remote changes.
-	 * Detect changes, push to Automerge docs, upload to server. No bidirectional wait, no pull.
+	 * Recreate documents that failed to sync. Creates new Automerge documents
+	 * with the same content and updates all references (snapshot, parent directory).
+	 * Returns new handles that should be retried for sync.
 	 */
-	async pushToRemote(): Promise<SyncResult> {
-		const result: SyncResult = {
-			success: false,
-			filesChanged: 0,
-			directoriesChanged: 0,
-			errors: [],
-			warnings: [],
-		}
-
-		// Reset tracked handles for sync
-		this.handlesByPath = new Map()
+	private async recreateFailedDocuments(
+		failedHandles: DocHandle<unknown>[],
+		snapshot: SyncSnapshot
+	): Promise<DocHandle<unknown>[]> {
+		const failedUrls = new Set(failedHandles.map(h => getPlainUrl(h.url)))
+		const newHandles: DocHandle<unknown>[] = []
 
-		try {
-			const snapshot =
-				(await this.snapshotManager.load()) ||
-				this.snapshotManager.createEmpty()
+		// Find which paths correspond to the failed handles
+		for (const [filePath, entry] of snapshot.files.entries()) {
+			const plainUrl = getPlainUrl(entry.url)
+			if (!failedUrls.has(plainUrl)) continue
 
-			debug(`pushToRemote: rootDirectoryUrl=${snapshot.rootDirectoryUrl?.slice(0, 30)}..., files=${snapshot.files.size}, dirs=${snapshot.directories.size}`)
+			debug(`recreate: recreating document for ${filePath} (${plainUrl.slice(0, 20)}...)`)
+			out.taskLine(`Recreating document for ${filePath}`)
 
-			// Detect all changes
-			debug("pushToRemote: detecting changes")
-			out.update("Detecting local changes")
-			const changes = await this.changeDetector.detectChanges(snapshot)
+			try {
+				// Read the current content from the old handle
+				const oldHandle = await this.repo.find<FileDocument>(plainUrl)
+				const doc = await oldHandle.doc()
+				if (!doc) {
+					debug(`recreate: could not read doc for ${filePath}, skipping`)
+					continue
+				}
 
-			// Detect moves
-			const {moves, remainingChanges} = await this.moveDetector.detectMoves(
-				changes,
-				snapshot
-			)
+				const content = readDocContent(doc.content)
+				if (content === null) {
+					debug(`recreate: null content for ${filePath}, skipping`)
+					continue
+				}
 
-			debug(`pushToRemote: detected ${changes.length} changes, ${moves.length} moves, ${remainingChanges.length} remaining`)
+				// Create a fresh document
+				const fakeChange: DetectedChange = {
+					path: filePath,
+					changeType: ChangeType.LOCAL_ONLY,
+					fileType: this.isTextContent(content) ? FileType.TEXT : FileType.BINARY,
+					localContent: content,
+					remoteContent: null,
+				}
+				const newHandle = await this.createRemoteFile(fakeChange)
+				if (!newHandle) continue
 
-			// Push local changes to remote
-			debug("pushToRemote: pushing local changes")
-			const pushResult = await this.pushLocalChanges(
-				remainingChanges,
-				moves,
-				snapshot
-			)
+				const entryUrl = this.getEntryUrl(newHandle, filePath)
 
-			result.filesChanged += pushResult.filesChanged
-			result.directoriesChanged += pushResult.directoriesChanged
-			result.errors.push(...pushResult.errors)
-			result.warnings.push(...pushResult.warnings)
+				// Update snapshot entry
+				this.snapshotManager.updateFileEntry(snapshot, filePath, {
+					...entry,
+					url: entryUrl,
+					head: newHandle.heads(),
+					...(this.isArtifactPath(filePath) ? {contentHash: contentHash(content)} : {}),
+				})
 
-			debug(`pushToRemote: push complete - ${pushResult.filesChanged} files, ${pushResult.directoriesChanged} dirs changed`)
+				// Update parent directory entry to point to new document
+				const pathParts = filePath.split("/")
+				const fileName = pathParts.pop() || ""
+				const dirPath = pathParts.join("/")
 
-			// Touch root directory if any changes were made
-			const hasChanges =
-				result.filesChanged > 0 || result.directoriesChanged > 0
-			if (hasChanges) {
-				await this.touchRootDirectory(snapshot)
-			}
+				let dirUrl: AutomergeUrl
+				if (!dirPath || dirPath === "") {
+					dirUrl = snapshot.rootDirectoryUrl!
+				} else {
+					const dirEntry = snapshot.directories.get(dirPath)
+					if (!dirEntry) continue
+					dirUrl = dirEntry.url
+				}
 
-			// Wait for network sync (upload to server)
-			if (this.config.sync_enabled) {
-				try {
-					// Ensure root directory handle is tracked for sync
-					if (snapshot.rootDirectoryUrl) {
-						const rootHandle =
-							await this.repo.find<DirectoryDocument>(
-								snapshot.rootDirectoryUrl
-							)
-						this.handlesByPath.set("", rootHandle)
+				const dirHandle = await this.repo.find<DirectoryDocument>(getPlainUrl(dirUrl))
+				dirHandle.change((d: DirectoryDocument) => {
+					const idx = d.docs.findIndex(
+						e => e.name === fileName && e.type === "file"
+					)
+					if (idx !== -1) {
+						d.docs[idx].url = entryUrl
 					}
+				})
 
-					if (this.handlesByPath.size > 0) {
-						const allHandles = Array.from(
-							this.handlesByPath.values()
-						)
-						debug(`pushToRemote: waiting for ${allHandles.length} handles to sync to server`)
-						out.update(`Uploading ${allHandles.length} documents to sync server`)
-						await waitForSync(
-							allHandles,
-							this.config.sync_server_storage_id
-						)
-						debug("pushToRemote: all handles synced to server")
-					}
-				} catch (error) {
-					debug(`pushToRemote: network sync error: ${error}`)
-					out.taskLine(`Network sync failed: ${error}`, true)
-					result.warnings.push(`Network sync failed: ${error}`)
-				}
+				// Track new handles
+				this.handlesByPath.set(filePath, newHandle)
+				this.handlesByPath.set(dirPath, dirHandle)
+				newHandles.push(newHandle)
+				newHandles.push(dirHandle)
+
+				debug(`recreate: created new doc for ${filePath} -> ${newHandle.url.slice(0, 20)}...`)
+			} catch (error) {
+				debug(`recreate: failed for ${filePath}: ${error}`)
+				out.taskLine(`Failed to recreate ${filePath}: ${error}`, true)
 			}
+		}
 
-			// Save updated snapshot
-			await this.snapshotManager.save(snapshot)
+		// Also check directory documents
+		for (const [dirPath, entry] of snapshot.directories.entries()) {
+			const plainUrl = getPlainUrl(entry.url)
+			if (!failedUrls.has(plainUrl)) continue
 
-			result.success = result.errors.length === 0
-			return result
-		} catch (error) {
-			result.errors.push({
-				path: "push",
-				operation: "push-to-remote",
-				error: error as Error,
-				recoverable: false,
-			})
-			return result
+			// Directory docs can't be easily recreated (they reference children).
+			// Just log a warning — the child recreation above should handle most cases.
+			debug(`recreate: directory ${dirPath || "(root)"} failed to sync, cannot recreate`)
+			out.taskLine(`Warning: directory ${dirPath || "(root)"} failed to sync`, true)
 		}
+
+		return newHandles
 	}
 
 	/**
@@ -445,10 +448,29 @@ export class SyncEngine {
 						const handlePaths = Array.from(this.handlesByPath.keys())
 						debug(`sync: waiting for ${allHandles.length} handles to sync to server: ${handlePaths.slice(0, 10).map(p => p || "(root)").join(", ")}${handlePaths.length > 10 ? ` ...and ${handlePaths.length - 10} more` : ""}`)
 						out.update(`Uploading ${allHandles.length} documents to sync server`)
-						await waitForSync(
+						const {failed} = await waitForSync(
 							allHandles,
 							this.config.sync_server_storage_id
 						)
+
+						// Recreate failed documents and retry once
+						if (failed.length > 0) {
+							debug(`sync: ${failed.length} documents failed, recreating`)
+							out.update(`Recreating ${failed.length} failed documents`)
+							const retryHandles = await this.recreateFailedDocuments(failed, snapshot)
+							if (retryHandles.length > 0) {
+								debug(`sync: retrying ${retryHandles.length} recreated handles`)
+								out.update(`Retrying ${retryHandles.length} recreated documents`)
+								const retry = await waitForSync(
+									retryHandles,
+									this.config.sync_server_storage_id
+								)
+								if (retry.failed.length > 0) {
+									result.warnings.push(`${retry.failed.length} documents still failed after recreation`)
+								}
+							}
+						}
+
 						debug("sync: all handles synced to server")
 					}
 
@@ -714,6 +736,9 @@ export class SyncEngine {
 									head: handle.heads(),
 									extension: getFileExtension(change.path),
 									mimeType: getEnhancedMimeType(change.path),
+									...(this.isArtifactPath(change.path) && change.localContent
+										? {contentHash: contentHash(change.localContent)}
+										: {}),
 								}
 							)
 							result.filesChanged++
@@ -936,42 +961,66 @@ export class SyncEngine {
 
 		// 3) Update the FileDocument name and content to match new location/state
 		try {
-			// Use plain URL for mutable handle
-			const handle = await this.repo.find<FileDocument>(
-				getPlainUrl(fromEntry.url)
-			)
-			const heads = fromEntry.head
-
-			// Update both name and content (if content changed during move)
-			changeWithOptionalHeads(handle, heads, (doc: FileDocument) => {
-				doc.name = toFileName
-
-				// If new content is provided, update it (handles move + modification case)
-				if (move.newContent !== undefined) {
-					if (typeof move.newContent === "string") {
-						updateTextContent(doc, ["content"], move.newContent)
-					} else {
-						doc.content = move.newContent
-					}
+			let entryUrl: AutomergeUrl
+			let finalHeads: UrlHeads
+
+			if (this.isArtifactPath(move.toPath)) {
+				// Artifact files use RawString — no diffing needed, just create a fresh doc
+				const content = move.newContent !== undefined
+					? move.newContent
+					: readDocContent((await (await this.repo.find<FileDocument>(getPlainUrl(fromEntry.url))).doc())?.content)
+				const fakeChange: DetectedChange = {
+					path: move.toPath,
+					changeType: ChangeType.LOCAL_ONLY,
+					fileType: content != null && typeof content === "string" ? FileType.TEXT : FileType.BINARY,
+					localContent: content,
+					remoteContent: null,
 				}
-			})
+				const newHandle = await this.createRemoteFile(fakeChange)
+				if (!newHandle) return
+				entryUrl = this.getEntryUrl(newHandle, move.toPath)
+				finalHeads = newHandle.heads()
+			} else {
+				// Use plain URL for mutable handle
+				const handle = await this.repo.find<FileDocument>(
+					getPlainUrl(fromEntry.url)
+				)
+				const heads = fromEntry.head
+
+				// Update both name and content (if content changed during move)
+				changeWithOptionalHeads(handle, heads, (doc: FileDocument) => {
+					doc.name = toFileName
+
+					// If new content is provided, update it (handles move + modification case)
+					if (move.newContent !== undefined) {
+						if (typeof move.newContent === "string") {
+							updateTextContent(doc, ["content"], move.newContent)
+						} else {
+							doc.content = move.newContent
+						}
+					}
+				})
 
-			// Get appropriate URL for directory entry
-			const entryUrl = this.getEntryUrl(handle, move.toPath)
+				entryUrl = this.getEntryUrl(handle, move.toPath)
+				finalHeads = handle.heads()
+
+				// Track file handle for network sync
+				this.handlesByPath.set(move.toPath, handle)
+			}
 
 			// 4) Add file entry to destination directory
 			await this.addFileToDirectory(snapshot, move.toPath, entryUrl)
 
-			// Track file handle for network sync
-			this.handlesByPath.set(move.toPath, handle)
-
 			// 5) Update snapshot entries
 			this.snapshotManager.removeFileEntry(snapshot, move.fromPath)
 			this.snapshotManager.updateFileEntry(snapshot, move.toPath, {
 				...fromEntry,
 				path: joinAndNormalizePath(this.rootPath, move.toPath),
 				url: entryUrl,
-				head: handle.heads(),
+				head: finalHeads,
+				...(this.isArtifactPath(move.toPath) && move.newContent != null
+					? {contentHash: contentHash(move.newContent)}
+					: {}),
 			})
 		} catch (e) {
 			// Failed to update file name - file may have been deleted
@@ -1076,6 +1125,9 @@ export class SyncEngine {
 					head: newHandle.heads(),
 					extension: getFileExtension(filePath),
 					mimeType: getEnhancedMimeType(filePath),
+					...(this.isArtifactPath(filePath)
+						? {contentHash: contentHash(content)}
+						: {}),
 				})
 			}
 			return
@@ -1130,27 +1182,14 @@ export class SyncEngine {
 	 * Delete remote file document
 	 */
 	private async deleteRemoteFile(
-		url: AutomergeUrl,
-		snapshot?: SyncSnapshot,
-		filePath?: string
+		_url: AutomergeUrl,
+		_snapshot?: SyncSnapshot,
+		_filePath?: string
 	): Promise<void> {
-		// In Automerge, we don't actually delete documents
-		// They become orphaned and will be garbage collected
-		// For now, we just mark them as deleted by clearing content
-		// Use plain URL for mutable handle
-		const handle = await this.repo.find<FileDocument>(getPlainUrl(url))
-		// const doc = await handle.doc(); // no longer needed
-		let heads
-		if (snapshot && filePath) {
-			heads = snapshot.files.get(filePath)?.head
-		}
-		changeWithOptionalHeads(handle, heads, (doc: FileDocument) => {
-			if (doc.content instanceof Uint8Array) {
-				doc.content = new Uint8Array(0)
-			} else {
-				updateTextContent(doc, ["content"], "")
-			}
-		})
+		// In Automerge, we don't actually delete documents.
+		// The file entry is removed from its parent directory, making the
+		// document orphaned. Clearing content via splice is expensive for
+		// large text files (every character is a CRDT op), so we skip it.
 	}
 
 	/**

package/src/types/config.ts

@@ -101,11 +101,6 @@ export interface StatusOptions extends CommandOptions {
   verbose?: boolean;
 }
 
-/**
- * Push command specific options
- */
-export interface PushOptions extends CommandOptions {}
-
 /**
  * Watch command specific options
  */

package/src/types/snapshot.ts

@@ -9,6 +9,7 @@ export interface SnapshotFileEntry {
   head: UrlHeads; // Document head at last sync
   extension: string; // File extension
   mimeType: string; // MIME type
+  contentHash?: string; // SHA-256 of content at last sync (used by artifact files to skip remote reads)
 }
 
 /**

package/src/utils/content.ts

@@ -1,3 +1,13 @@
+import { createHash } from "crypto";
+
+/**
+ * Compute a SHA-256 hash of file content.
+ * Used to detect local changes for artifact files without reading remote docs.
+ */
+export function contentHash(content: string | Uint8Array): string {
+  return createHash("sha256").update(content).digest("hex");
+}
+
 /**
  * Compare two content pieces for equality
  */