pushwork 1.0.25 → 1.0.27

package/src/core/sync-engine.ts

@@ -356,130 +356,6 @@ export class SyncEngine {
 		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
 	 */
@@ -506,6 +382,36 @@ export class SyncEngine {
 
 			// Wait for initial sync to receive any pending remote changes
 			if (this.config.sync_enabled && snapshot.rootDirectoryUrl) {
+				debug("sync: waiting for root document to be ready")
+				out.update("Waiting for root document from server")
+
+				// Wait for the root document to be fetched from the network.
+				// repo.find() rejects with "unavailable" if the server doesn't
+				// have the document yet, so we retry with backoff.
+				// This is critical for clone scenarios.
+				const plainRootUrl = getPlainUrl(snapshot.rootDirectoryUrl)
+				const maxAttempts = 6
+				for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+					try {
+						const rootHandle = await this.repo.find<DirectoryDocument>(plainRootUrl)
+						rootHandle.doc() // throws if not ready
+						debug(`sync: root document ready (attempt ${attempt})`)
+						break
+					} catch (error) {
+						const isUnavailable = String(error).includes("unavailable") || String(error).includes("not ready")
+						if (isUnavailable && attempt < maxAttempts) {
+							const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000)
+							debug(`sync: root document not available (attempt ${attempt}/${maxAttempts}), retrying in ${delay}ms`)
+							out.update(`Waiting for root document (attempt ${attempt}/${maxAttempts})`)
+							await new Promise(r => setTimeout(r, delay))
+						} else {
+							debug(`sync: root document unavailable after ${maxAttempts} attempts: ${error}`)
+							out.taskLine(`Root document unavailable: ${error}`, true)
+							break
+						}
+					}
+				}
+
 				debug("sync: waiting for initial bidirectional sync")
 				out.update("Waiting for initial sync from server")
 				try {
@@ -514,7 +420,7 @@ export class SyncEngine {
 						snapshot.rootDirectoryUrl,
 						this.config.sync_server_storage_id,
 						{
-							timeoutMs: 3000, // Short timeout for initial sync
+							timeoutMs: 5000, // Increased timeout for initial sync
 							pollIntervalMs: 100,
 							stableChecksRequired: 3,
 						}

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/test/integration/fuzzer.test.ts

@@ -26,26 +26,59 @@ describe("Pushwork Fuzzer", () => {
   });
 
   /**
-   * Helper: Execute pushwork CLI command
+   * Helper: Wait for a short time (useful for allowing sync to complete)
+   */
+  async function wait(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Helper: Execute pushwork CLI command with retry logic for transient errors
    */
   async function pushwork(
     args: string[],
-    cwd: string
+    cwd: string,
+    maxRetries: number = 3
   ): Promise<{ stdout: string; stderr: string }> {
-    try {
-      const result = await execFilePromise("node", [PUSHWORK_CLI, ...args], {
-        cwd,
-        env: { ...process.env, FORCE_COLOR: "0" }, // Disable color codes for cleaner output
-      });
-      return result;
-    } catch (error: any) {
-      // execFile throws on non-zero exit code, but we still want stdout/stderr
-      throw new Error(
-        `pushwork ${args.join(" ")} failed: ${error.message}\nstdout: ${
-          error.stdout
-        }\nstderr: ${error.stderr}`
-      );
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const result = await execFilePromise("node", [PUSHWORK_CLI, ...args], {
+          cwd,
+          env: { ...process.env, FORCE_COLOR: "0" }, // Disable color codes for cleaner output
+        });
+        return result;
+      } catch (error: any) {
+        lastError = error;
+        const errorMessage = error.message + (error.stderr || "");
+
+        // Retry on transient server errors (502, 503, connection refused, unavailable)
+        const isTransient =
+          errorMessage.includes("502") ||
+          errorMessage.includes("503") ||
+          errorMessage.includes("ECONNREFUSED") ||
+          errorMessage.includes("ETIMEDOUT") ||
+          errorMessage.includes("unavailable");
+
+        if (isTransient && attempt < maxRetries) {
+          // Exponential backoff: 1s, 2s, 4s
+          const delay = Math.pow(2, attempt - 1) * 1000;
+          await wait(delay);
+          continue;
+        }
+
+        // Non-transient error or exhausted retries
+        throw new Error(
+          `pushwork ${args.join(" ")} failed: ${error.message}\nstdout: ${
+            error.stdout
+          }\nstderr: ${error.stderr}`
+        );
+      }
     }
+
+    // Should never reach here, but TypeScript needs this
+    throw lastError;
   }
 
   /**
@@ -104,13 +137,6 @@ describe("Pushwork Fuzzer", () => {
     return files;
   }
 
-  /**
-   * Helper: Wait for a short time (useful for allowing sync to complete)
-   */
-  async function wait(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
   describe("Basic Setup and Clone", () => {
     it("should initialize a repo with a single file and clone it successfully", async () => {
       // Create two directories for testing
@@ -681,18 +707,28 @@ describe("Pushwork Fuzzer", () => {
               // Initialize repo A with an initial file
               await fs.writeFile(path.join(repoA, "initial.txt"), "initial");
               await pushwork(["init", "."], repoA);
-              await wait(500);
+              // Give sync server time to store and propagate the document
+              await wait(2000);
 
               // Get root URL and clone to B
               const { stdout: rootUrl } = await pushwork(["url"], repoA);
               const cleanRootUrl = rootUrl.trim();
-              await pushwork(["clone", cleanRootUrl, repoB], testRoot);
-              await wait(500);
+              // Clone with extra retries - document availability can be delayed
+              await pushwork(["clone", cleanRootUrl, repoB], testRoot, 5);
+              await wait(1000);
 
               // Verify initial state matches
+              const filesA = await getAllFiles(repoA);
+              const filesB = await getAllFiles(repoB);
               const hashBeforeOps = await hashDirectory(repoA);
               const hashB1 = await hashDirectory(repoB);
-              expect(hashBeforeOps).toBe(hashB1);
+              if (hashBeforeOps !== hashB1) {
+                throw new Error(
+                  `Initial hash mismatch!\n` +
+                  `  repoA (${repoA}):\n    files: ${JSON.stringify(filesA)}\n    hash: ${hashBeforeOps}\n` +
+                  `  repoB (${repoB}):\n    files: ${JSON.stringify(filesB)}\n    hash: ${hashB1}`
+                );
+              }
 
               // Apply operations to both sides
               await applyOperations(repoA, opsA);
@@ -762,7 +798,7 @@ describe("Pushwork Fuzzer", () => {
         ),
         {
           numRuns: 5, // INTENSE MODE (was 20, then cranked to 50)
-          timeout: 60000, // 1 minute timeout per run
+          timeout: 120000, // 2 minute timeout per run
           verbose: true, // Verbose output
           endOnFailure: true, // Stop on first failure to debug
         }