Fix push

Author: nightnei

apps/local/src/index.ts

@@ -1212,10 +1212,22 @@ export async function startLocalServer( options: LocalServerOptions ): Promise<
 					executeCliCommand: execute,
 					accessToken: token.accessToken,
 					emit: ( output ) =>
-						sseSend( {
-							channel: 'sync',
-							payload: { ...output, siteId: req.params.id, remoteSiteId },
-						} ),
+						sseSend(
+							output.kind === 'import-progress'
+								? {
+										channel: 'sync-push',
+										payload: {
+											status: output.status,
+											progress: output.progress,
+											siteId: req.params.id,
+											remoteSiteId,
+										},
+								  }
+								: {
+										channel: 'sync',
+										payload: { ...output, siteId: req.params.id, remoteSiteId },
+								  }
+						),
 				},
 				{ sitePath: site.path, remoteSiteId, options }
 			);

apps/studio/src/ipc-utils.ts

@@ -8,7 +8,7 @@ import type { AgentRunEvent } from '@studio/common/ai/agent-events';
 import type { AiSessionPlacementUpdatedEvent } from '@studio/common/ai/sessions/placement';
 import type { RemoteSessionStatus } from '@studio/common/lib/remote-session';
 import type { StoredAuthToken } from '@studio/common/lib/shared-config';
-import type { PullSiteProgress } from '@studio/common/types/sync';
+import type { PullSiteProgress, PushImportProgress } from '@studio/common/types/sync';
 
 type SnapshotEventData = {
 	action: PreviewCommandLoggerAction;
@@ -40,6 +40,7 @@ export interface IpcEvents {
 	'sync-upload-progress': [ { selectedSiteId: string; remoteSiteId: number; progress: number } ];
 	'sync-upload-manually-paused': [ { selectedSiteId: string; remoteSiteId: number } ];
 	'sync-pull-progress': [ PullSiteProgress & { siteId: string } ];
+	'sync-push-progress': [ PushImportProgress & { siteId: string; remoteSiteId: number } ];
 	'snapshot-error': [ { operationId: crypto.UUID; data: SnapshotEventData } ];
 	'snapshot-fatal-error': [ { operationId: crypto.UUID; data: { message: string } } ];
 	'snapshot-output': [ { operationId: crypto.UUID; data: SnapshotEventData } ];

apps/studio/src/modules/sync/lib/ipc-handlers.ts

@@ -592,6 +592,13 @@ export async function pushSiteToLive(
 						selectedSiteId,
 						remoteSiteId,
 					} );
+				} else if ( output.kind === 'import-progress' ) {
+					void sendIpcEventToRenderer( 'sync-push-progress', {
+						siteId: selectedSiteId,
+						remoteSiteId,
+						status: output.status,
+						progress: output.progress,
+					} );
 				}
 			},
 		},

apps/ui/src/data/core/connectors/ipc/index.ts

@@ -20,6 +20,7 @@ import type {
 	LoadedAiSession,
 	AppUpdateStatus,
 	ProposedSitePath,
+	PushImportProgress,
 	QuitSitesBehavior,
 	SelectedSiteFolder,
 	SiteDetails,
@@ -543,12 +544,29 @@ export function createIpcConnector(): Connector {
 			);
 		},
 
-		async pushSiteToLive( siteId, remoteSiteId, options ): Promise< void > {
+		async pushSiteToLive( siteId, remoteSiteId, options, onImportProgress ): Promise< void > {
 			// The agentic UI pushes via the shared `pushSite` (export → TUS
 			// upload → import) in both desktop and `studio ui`; the desktop runs
-			// it behind this single IPC handler. Resolves once the import is
-			// initiated (the remote import may still be running).
-			await ipcApi.pushSiteToLive( siteId, remoteSiteId, options );
+			// it behind this single IPC handler. Resolves once the remote import
+			// has fully finished; import progress streams in between.
+			const unsubscribe = onImportProgress
+				? ipcListener.subscribe(
+						'sync-push-progress',
+						( _event: unknown, payload: { siteId: string; status: string; progress: number } ) => {
+							if ( payload.siteId === siteId ) {
+								onImportProgress( {
+									status: payload.status as PushImportProgress[ 'status' ],
+									progress: payload.progress,
+								} );
+							}
+						}
+				  )
+				: undefined;
+			try {
+				await ipcApi.pushSiteToLive( siteId, remoteSiteId, options );
+			} finally {
+				unsubscribe?.();
+			}
 			await markConnectedWpcomSiteSynced( siteId, remoteSiteId, 'push' );
 		},
 

apps/ui/src/data/core/connectors/local/index.ts

@@ -20,6 +20,7 @@ import type {
 	ProposedSitePath,
 	QuitSitesBehavior,
 	PullSiteProgress,
+	PushImportProgress,
 	SelectedSiteFolder,
 	SiteDetails,
 	Snapshot,
@@ -65,6 +66,11 @@ type SnapshotSseOutput =
 	| { kind: 'success'; operationId: string }
 	| { kind: 'output' | 'error'; operationId: string };
 
+type PushProgressSseOutput = PushImportProgress & {
+	siteId: string;
+	remoteSiteId: number;
+};
+
 type PullProgressSseOutput = PullSiteProgress & {
 	siteId: string;
 	remoteSiteId: number;
@@ -78,6 +84,7 @@ type ServerEvent =
 	| { channel: 'placement'; payload: AiSessionPlacementUpdatedEvent }
 	| { channel: 'snapshot'; payload: SnapshotSseOutput }
 	| { channel: 'sync-pull'; payload: PullProgressSseOutput }
+	| { channel: 'sync-push'; payload: PushProgressSseOutput }
 	| { channel: 'import'; payload: ImportSseOutput }
 	| { channel: 'sync-connect'; payload: { remoteSiteId: number; studioSiteId: string } };
 
@@ -102,6 +109,7 @@ export function createLocalConnector( { apiBaseUrl }: LocalConnectorOptions ): C
 	const placementListeners = new Set< ( event: AiSessionPlacementUpdatedEvent ) => void >();
 	const snapshotListeners = new Set< ( output: SnapshotSseOutput ) => void >();
 	const pullProgressListeners = new Set< ( output: PullProgressSseOutput ) => void >();
+	const pushProgressListeners = new Set< ( output: PushProgressSseOutput ) => void >();
 	const importListeners = new Set< ( output: ImportSseOutput ) => void >();
 	const syncConnectListeners = new Set<
 		( event: { remoteSiteId: number; studioSiteId: string } ) => void
@@ -226,6 +234,8 @@ export function createLocalConnector( { apiBaseUrl }: LocalConnectorOptions ): C
 					snapshotListeners.forEach( ( listener ) => listener( parsed.payload ) );
 				} else if ( parsed.channel === 'sync-pull' ) {
 					pullProgressListeners.forEach( ( listener ) => listener( parsed.payload ) );
+				} else if ( parsed.channel === 'sync-push' ) {
+					pushProgressListeners.forEach( ( listener ) => listener( parsed.payload ) );
 				} else if ( parsed.channel === 'import' ) {
 					importListeners.forEach( ( listener ) => listener( parsed.payload ) );
 				} else if ( parsed.channel === 'sync-connect' ) {
@@ -573,11 +583,23 @@ export function createLocalConnector( { apiBaseUrl }: LocalConnectorOptions ): C
 				method: 'POST',
 			} );
 		},
-		async pushSiteToLive( siteId, remoteSiteId, options ) {
-			await api( `/sites/${ encodeURIComponent( siteId ) }/push`, {
-				method: 'POST',
-				body: JSON.stringify( { remoteSiteId, options } ),
-			} );
+		async pushSiteToLive( siteId, remoteSiteId, options, onImportProgress ) {
+			const listener = ( output: PushProgressSseOutput ) => {
+				if ( output.siteId === siteId ) {
+					onImportProgress?.( { status: output.status, progress: output.progress } );
+				}
+			};
+			if ( onImportProgress ) {
+				pushProgressListeners.add( listener );
+			}
+			try {
+				await api( `/sites/${ encodeURIComponent( siteId ) }/push`, {
+					method: 'POST',
+					body: JSON.stringify( { remoteSiteId, options } ),
+				} );
+			} finally {
+				pushProgressListeners.delete( listener );
+			}
 		},
 		async pullSiteFromLive( siteId, remoteSiteId, onProgress, options ) {
 			const listener = ( output: PullProgressSseOutput ) => {

apps/ui/src/data/core/index.ts

@@ -16,6 +16,7 @@ export type {
 	ProposedSitePath,
 	PullSiteProgress,
 	PullSyncOptions,
+	PushImportProgress,
 	PushSyncOptions,
 	QuitSitesBehavior,
 	SelectedSiteFolder,

apps/ui/src/data/core/types.ts

@@ -16,6 +16,7 @@ import type { Snapshot } from '@studio/common/types/snapshot';
 import type {
 	PullSiteProgress,
 	PullSyncOptions,
+	PushImportProgress,
 	PushSyncOptions,
 	SyncSite,
 } from '@studio/common/types/sync';
@@ -42,6 +43,7 @@ export type { Snapshot } from '@studio/common/types/snapshot';
 export type {
 	PullSiteProgress,
 	PullSyncOptions,
+	PushImportProgress,
 	PushSyncOptions,
 	SyncSite,
 } from '@studio/common/types/sync';
@@ -278,11 +280,14 @@ export interface Connector {
 	disconnectWpcomSite( localSiteId: string, remoteSiteId: number ): Promise< void >;
 	// Pushes the local site to a previously connected WordPress.com site.
 	// Replaces the remote contents with the local database and wp-content,
-	// or only the selection described by `options` when provided.
+	// or only the selection described by `options` when provided. Resolves
+	// once the remote import has fully finished; `onImportProgress` reports
+	// the remote backup/import phases in between.
 	pushSiteToLive(
 		siteId: string,
 		remoteSiteId: number,
-		options?: PushSyncOptions
+		options?: PushSyncOptions,
+		onImportProgress?: ( progress: PushImportProgress ) => void
 	): Promise< void >;
 	// Pulls the connected WordPress.com site's database + wp-content back
 	// into the local Studio site, or only the selection described by

apps/ui/src/data/queries/use-sync-site.ts

@@ -10,7 +10,12 @@ import {
 	reportSyncProgress,
 	reportSyncSuccess,
 } from '@/data/sync-activity';
-import type { PullSiteProgress, PullSyncOptions, PushSyncOptions } from '@/data/core';
+import type {
+	PullSiteProgress,
+	PullSyncOptions,
+	PushImportProgress,
+	PushSyncOptions,
+} from '@/data/core';
 
 // Mutation keys are exported so downstream consumers (e.g. a cross-page
 // activity indicator or future bulk-sync UI) can filter the react-query
@@ -24,13 +29,30 @@ type PushToLiveVariables = {
 	options?: PushSyncOptions;
 };
 
+// The remote applies a push in two phases (safety backup, then import); the
+// dropdown shows these while the push mutation stays pending.
+function getImportProgressMessage( status: PushImportProgress[ 'status' ] ): string {
+	if ( status === 'finished' ) {
+		return __( 'Finishing…' );
+	}
+	if ( status.startsWith( 'archive_import' ) ) {
+		return __( 'Applying changes to the live site…' );
+	}
+	return __( 'Backing up the live site…' );
+}
+
 export function usePushSiteToLive() {
 	const connector = useConnector();
 	const queryClient = useQueryClient();
 	return useMutation( {
 		mutationKey: PUSH_TO_LIVE_MUTATION_KEY,
 		mutationFn: ( { siteId, remoteSiteId, options }: PushToLiveVariables ) =>
-			connector.pushSiteToLive( siteId, remoteSiteId, options ),
+			connector.pushSiteToLive( siteId, remoteSiteId, options, ( importProgress ) => {
+				reportSyncProgress( siteId, 'push', {
+					message: getImportProgressMessage( importProgress.status ),
+					progress: importProgress.progress,
+				} );
+			} ),
 		onMutate: ( { siteId } ) => {
 			reportSyncPending( siteId, 'push' );
 		},

apps/ui/src/data/sync-activity.ts

@@ -62,7 +62,7 @@ export function reportSyncPending( siteId: string, direction: SyncDirection ): v
 
 export function reportSyncProgress(
 	siteId: string,
-	direction: Extract< SyncDirection, 'pull' >,
+	direction: Extract< SyncDirection, 'pull' | 'push' >,
 	progress: PullSiteProgress
 ): void {
 	clearExpiryTimer( siteId );

packages/common/sites/sync.ts

@@ -2,12 +2,17 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { initiateImport } from '@studio/common/lib/sync/sync-api';
+import {
+	SYNC_MAX_STALLED_ATTEMPTS,
+	SYNC_POLL_INTERVAL_MS,
+} from '@studio/common/lib/sync/constants';
+import { initiateImport, pollImportStatus } from '@studio/common/lib/sync/sync-api';
 import { createTusUpload } from '@studio/common/lib/sync/tus-upload';
 import type { ExecuteCliCommand } from '@studio/common/lib/cli-process';
 import type {
 	PullSiteProgress,
 	PullSyncOptions,
+	PushImportProgress,
 	PushSyncOptions,
 	SyncOption,
 } from '@studio/common/types/sync';
@@ -22,7 +27,8 @@ import type {
 export type PushOutput =
 	| { kind: 'upload-progress'; progress: number }
 	| { kind: 'network-paused'; error: string }
-	| { kind: 'resumed' };
+	| { kind: 'resumed' }
+	| ( { kind: 'import-progress' } & PushImportProgress );
 
 export interface PushSiteContext {
 	executeCliCommand: ExecuteCliCommand;
@@ -77,11 +83,63 @@ export async function pushSite(
 		const attachmentId = await promise;
 
 		await initiateImport( ctx.accessToken, params.remoteSiteId, attachmentId, params.options );
+
+		await waitForImportCompletion( ctx, params.remoteSiteId );
 	} finally {
 		await fs.promises.rm( dir, { recursive: true, force: true } ).catch( () => undefined );
 	}
 }
 
+// Polls the remote import status after initiation until the import finishes,
+// mirroring the classic renderer's push lifecycle so callers only resolve once
+// the live site has actually been updated. Emits overall progress: the remote
+// backup phase maps to 0-50 and the import phase to 50-100.
+async function waitForImportCompletion(
+	ctx: PushSiteContext,
+	remoteSiteId: number
+): Promise< void > {
+	let consecutiveErrors = 0;
+
+	for ( let attempt = 0; attempt < SYNC_MAX_STALLED_ATTEMPTS; attempt++ ) {
+		await new Promise( ( resolve ) => setTimeout( resolve, SYNC_POLL_INTERVAL_MS ) );
+
+		let response;
+		try {
+			response = await pollImportStatus( ctx.accessToken, remoteSiteId );
+			consecutiveErrors = 0;
+		} catch ( error ) {
+			// Tolerate transient network/API errors while the remote works.
+			if ( ++consecutiveErrors >= 5 ) {
+				throw error;
+			}
+			continue;
+		}
+
+		if ( response.status === 'failed' ) {
+			throw new Error( response.error || 'Import failed on the remote site.' );
+		}
+		if ( ! response.success ) {
+			throw new Error( 'Import failed on the remote site.' );
+		}
+
+		let progress = 0;
+		if ( response.status === 'finished' ) {
+			progress = 100;
+		} else if ( response.status.startsWith( 'archive_import' ) ) {
+			progress = 50 + ( response.import_progress ?? 0 ) / 2;
+		} else {
+			progress = ( response.backup_progress ?? 0 ) / 2;
+		}
+		ctx.emit?.( { kind: 'import-progress', status: response.status, progress } );
+
+		if ( response.status === 'finished' ) {
+			return;
+		}
+	}
+
+	throw new Error( 'Import timed out' );
+}
+
 // Mirrors the legacy renderer's export-mode derivation
 // (apps/studio/src/modules/sync/lib/ipc-handlers.ts `exportSiteForPush`):
 // no options (or 'all') exports the full site.