pushwork 1.0.21 → 1.0.25

package/src/core/change-detection.ts

@@ -17,7 +17,7 @@ import {
 	getPlainUrl,
 	readDocContent,
 } from "../utils"
-import {isContentEqual} from "../utils/content"
+import {isContentEqual, contentHash} from "../utils/content"
 import {out} from "../utils/output"
 
 /**
@@ -27,9 +27,21 @@ export class ChangeDetector {
 	constructor(
 		private repo: Repo,
 		private rootPath: string,
-		private excludePatterns: string[] = []
+		private excludePatterns: string[] = [],
+		private artifactDirectories: string[] = []
 	) {}
 
+	/**
+	 * Check if a file path is inside an artifact directory.
+	 * Artifact files use RawString and are always replaced wholesale,
+	 * so we can skip expensive remote content reads for them.
+	 */
+	private isArtifactPath(filePath: string): boolean {
+		return this.artifactDirectories.some(
+			dir => filePath === dir || filePath.startsWith(dir + "/")
+		)
+	}
+
 	/**
 	 * Detect all changes between local filesystem and snapshot
 	 */
@@ -78,6 +90,35 @@ export class ChangeDetector {
 							localContent: fileInfo.content,
 							remoteContent: null,
 						})
+					} else if (this.isArtifactPath(relativePath)) {
+						// Artifact files are always replaced wholesale (RawString).
+						// Skip remote doc content reads — compare local hash against
+						// stored hash to detect local changes, and check heads for remote.
+						const localHash = contentHash(fileInfo.content)
+						const localChanged = snapshotEntry.contentHash
+							? localHash !== snapshotEntry.contentHash
+							: true // No stored hash = first sync with hash support, assume changed
+
+						const remoteHead = await this.getCurrentRemoteHead(
+							snapshotEntry.url
+						)
+						const remoteChanged = !A.equals(remoteHead, snapshotEntry.head)
+
+						if (localChanged || remoteChanged) {
+							changes.push({
+								path: relativePath,
+								changeType: localChanged && remoteChanged
+									? ChangeType.BOTH_CHANGED
+									: localChanged
+										? ChangeType.LOCAL_ONLY
+										: ChangeType.REMOTE_ONLY,
+								fileType: fileInfo.type,
+								localContent: fileInfo.content,
+								remoteContent: null,
+								localHead: snapshotEntry.head,
+								remoteHead,
+							})
+						}
 					} else {
 						// Check if content changed
 						const lastKnownContent = await this.getContentAtHead(
@@ -129,6 +170,27 @@ export class ChangeDetector {
 			Array.from(snapshot.files.entries())
 				.filter(([relativePath]) => !currentFiles.has(relativePath))
 				.map(async ([relativePath, snapshotEntry]) => {
+					if (this.isArtifactPath(relativePath)) {
+						// Artifact deletion: skip remote content read
+						const remoteHead = await this.getCurrentRemoteHead(
+							snapshotEntry.url
+						)
+						const remoteChanged = !A.equals(remoteHead, snapshotEntry.head)
+
+						changes.push({
+							path: relativePath,
+							changeType: remoteChanged
+								? ChangeType.BOTH_CHANGED
+								: ChangeType.LOCAL_ONLY,
+							fileType: FileType.TEXT,
+							localContent: null,
+							remoteContent: null,
+							localHead: snapshotEntry.head,
+							remoteHead,
+						})
+						return
+					}
+
 					// File was deleted locally
 					const currentRemoteContent = await this.getCurrentRemoteContent(
 						snapshotEntry.url
@@ -204,6 +266,23 @@ export class ChangeDetector {
 					)
 
 					if (!A.equals(currentRemoteHead, snapshotEntry.head)) {
+						if (this.isArtifactPath(relativePath)) {
+							// Artifact: skip content reads, just report head change
+							const localContent = await this.getLocalContent(relativePath)
+							changes.push({
+								path: relativePath,
+								changeType: localContent !== null
+									? ChangeType.BOTH_CHANGED
+									: ChangeType.REMOTE_ONLY,
+								fileType: FileType.TEXT,
+								localContent,
+								remoteContent: null,
+								localHead: snapshotEntry.head,
+								remoteHead: currentRemoteHead,
+							})
+							return
+						}
+
 						// Remote document has changed
 						const currentRemoteContent = await this.getCurrentRemoteContent(
 							snapshotEntry.url

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)
 	}
@@ -248,6 +249,237 @@ export class SyncEngine {
 		}
 	}
 
+	/**
+	 * 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.
+	 */
+	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>[] = []
+
+		// 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(`recreate: recreating document for ${filePath} (${plainUrl.slice(0, 20)}...)`)
+			out.taskLine(`Recreating document for ${filePath}`)
+
+			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
+				}
+
+				const content = readDocContent(doc.content)
+				if (content === null) {
+					debug(`recreate: null content for ${filePath}, skipping`)
+					continue
+				}
+
+				// 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
+
+				const entryUrl = this.getEntryUrl(newHandle, filePath)
+
+				// Update snapshot entry
+				this.snapshotManager.updateFileEntry(snapshot, filePath, {
+					...entry,
+					url: entryUrl,
+					head: newHandle.heads(),
+					...(this.isArtifactPath(filePath) ? {contentHash: contentHash(content)} : {}),
+				})
+
+				// Update parent directory entry to point to new document
+				const pathParts = filePath.split("/")
+				const fileName = pathParts.pop() || ""
+				const dirPath = pathParts.join("/")
+
+				let dirUrl: AutomergeUrl
+				if (!dirPath || dirPath === "") {
+					dirUrl = snapshot.rootDirectoryUrl!
+				} else {
+					const dirEntry = snapshot.directories.get(dirPath)
+					if (!dirEntry) continue
+					dirUrl = dirEntry.url
+				}
+
+				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
+					}
+				})
+
+				// 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)
+			}
+		}
+
+		// Also check directory documents
+		for (const [dirPath, entry] of snapshot.directories.entries()) {
+			const plainUrl = getPlainUrl(entry.url)
+			if (!failedUrls.has(plainUrl)) continue
+
+			// 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
+	}
+
+	/**
+	 * Push local changes to server without pulling remote changes.
+	 * Detect changes, push to Automerge docs, upload to server. No bidirectional wait, no pull.
+	 */
+	async pushToRemote(): Promise<SyncResult> {
+		const result: SyncResult = {
+			success: false,
+			filesChanged: 0,
+			directoriesChanged: 0,
+			errors: [],
+			warnings: [],
+		}
+
+		// Reset tracked handles for sync
+		this.handlesByPath = new Map()
+
+		try {
+			const snapshot =
+				(await this.snapshotManager.load()) ||
+				this.snapshotManager.createEmpty()
+
+			debug(`pushToRemote: rootDirectoryUrl=${snapshot.rootDirectoryUrl?.slice(0, 30)}..., files=${snapshot.files.size}, dirs=${snapshot.directories.size}`)
+
+			// Detect all changes
+			debug("pushToRemote: detecting changes")
+			out.update("Detecting local changes")
+			const changes = await this.changeDetector.detectChanges(snapshot)
+
+			// Detect moves
+			const {moves, remainingChanges} = await this.moveDetector.detectMoves(
+				changes,
+				snapshot
+			)
+
+			debug(`pushToRemote: detected ${changes.length} changes, ${moves.length} moves, ${remainingChanges.length} remaining`)
+
+			// Push local changes to remote
+			debug("pushToRemote: pushing local changes")
+			const pushResult = await this.pushLocalChanges(
+				remainingChanges,
+				moves,
+				snapshot
+			)
+
+			result.filesChanged += pushResult.filesChanged
+			result.directoriesChanged += pushResult.directoriesChanged
+			result.errors.push(...pushResult.errors)
+			result.warnings.push(...pushResult.warnings)
+
+			debug(`pushToRemote: push complete - ${pushResult.filesChanged} files, ${pushResult.directoriesChanged} dirs changed`)
+
+			// Touch root directory if any changes were made
+			const hasChanges =
+				result.filesChanged > 0 || result.directoriesChanged > 0
+			if (hasChanges) {
+				await this.touchRootDirectory(snapshot)
+			}
+
+			// 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)
+					}
+
+					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`)
+						const {failed} = await waitForSync(
+							allHandles,
+							this.config.sync_server_storage_id
+						)
+
+						// Recreate failed documents and retry once
+						if (failed.length > 0) {
+							debug(`pushToRemote: ${failed.length} documents failed, recreating`)
+							out.update(`Recreating ${failed.length} failed documents`)
+							const retryHandles = await this.recreateFailedDocuments(failed, snapshot)
+							if (retryHandles.length > 0) {
+								debug(`pushToRemote: 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("pushToRemote: sync to server complete")
+					}
+				} catch (error) {
+					debug(`pushToRemote: network sync error: ${error}`)
+					out.taskLine(`Network sync failed: ${error}`, true)
+					result.warnings.push(`Network sync failed: ${error}`)
+				}
+			}
+
+			// Save updated snapshot
+			await this.snapshotManager.save(snapshot)
+
+			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
+		}
+	}
+
 	/**
 	 * Run full bidirectional sync
 	 */
@@ -340,15 +572,36 @@ 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")
 					}
 
 					// Wait for bidirectional sync to stabilize
-					debug("sync: waiting for bidirectional sync to stabilize")
+					// Use tracked handles for post-push check (cheaper than full tree scan)
+					const changedHandles = Array.from(this.handlesByPath.values())
+					debug(`sync: waiting for bidirectional sync to stabilize (${changedHandles.length} tracked handles)`)
 					out.update("Waiting for bidirectional sync to stabilize")
 					await waitForBidirectionalSync(
 						this.repo,
@@ -358,6 +611,7 @@ export class SyncEngine {
 							timeoutMs: BIDIRECTIONAL_SYNC_TIMEOUT_MS,
 							pollIntervalMs: 100,
 							stableChecksRequired: 3,
+							handles: changedHandles.length > 0 ? changedHandles : undefined,
 						}
 					)
 				} catch (error) {
@@ -606,6 +860,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++
@@ -828,42 +1085,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
@@ -968,6 +1249,9 @@ export class SyncEngine {
 					head: newHandle.heads(),
 					extension: getFileExtension(filePath),
 					mimeType: getEnhancedMimeType(filePath),
+					...(this.isArtifactPath(filePath)
+						? {contentHash: contentHash(content)}
+						: {}),
 				})
 			}
 			return
@@ -1022,27 +1306,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,6 +101,11 @@ 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
  */