Fix stop render

renderer.js

@@ -97,59 +97,167 @@ export async function doRender(
 	const remotionArgs = ['-y', 'remotion', target, ...buildParams.trim().split(/\s+/).filter(arg => arg), renderComposition, outFile];
 	const cmd = `npx ${remotionArgs.join(' ')}`;
 	const spawnOptions = {
-		detached: false,
-		shell: true // Always use shell for proper parameter parsing
+		detached: true, // Always detach to create new process group
+		shell: true, // Use shell for proper parameter parsing
+		stdio: ['ignore', 'pipe', 'pipe'] // Ensure we can capture output
 	};
 
-	if (platform() === 'win32') {
+	// On Unix systems, create a new process group for easier cleanup
+	if (platform() !== 'win32') {
 		spawnOptions.detached = true;
 	}
 
 	const childProcess = spawn('npx', remotionArgs, spawnOptions);
 	let isProcessKilled = false;
+	let processTreePids = new Set(); // Track all process PIDs for cleanup
+
+	// Function to find and kill all child processes
+	const killProcessTree = async (pid, signal = 'SIGTERM') => {
+		try {
+			if (platform() === 'win32') {
+				// On Windows, use taskkill to kill the entire process tree
+				const { exec } = await import('child_process');
+				return new Promise((resolve) => {
+					exec(`taskkill /pid ${pid} /t /f`, (error) => {
+						if (error && !error.message.includes('not found')) {
+							console.error('Failed to kill Windows process tree:', error.message);
+						} else {
+							console.log(`Windows process tree ${pid} killed`);
+						}
+						resolve();
+					});
+				});
+			} else {
+				// On Unix systems, kill the process group
+				try {
+					process.kill(-pid, signal);
+					console.log(`Unix process group ${pid} killed with ${signal}`);
+				} catch (e) {
+					if (e.code !== 'ESRCH') {
+						// Try individual process kill as fallback
+						try {
+							process.kill(pid, signal);
+							console.log(`Unix process ${pid} killed with ${signal}`);
+						} catch (e2) {
+							if (e2.code !== 'ESRCH') {
+								console.error('Failed to kill Unix process:', e2.message);
+							}
+						}
+					}
+				}
+			}
+		} catch (e) {
+			if (e.code !== 'ESRCH') {
+				console.error('Failed to kill process tree:', e.message);
+			}
+		}
+	};
+
+	// Additional cleanup function to kill any remaining remotion processes
+	const killRemainingRemotionProcesses = async () => {
+		try {
+			if (platform() === 'win32') {
+				// On Windows, find and kill remotion processes
+				const { exec } = await import('child_process');
+				exec('tasklist /fi "imagename eq node.exe" /fo csv | findstr remotion', (error, stdout) => {
+					if (!error && stdout) {
+						console.log('Found remaining remotion processes, attempting cleanup...');
+						exec('taskkill /f /im node.exe /fi "windowtitle eq *remotion*"', (killError) => {
+							if (!killError) {
+								console.log('Cleaned up remaining remotion processes');
+							}
+						});
+					}
+				});
+			} else {
+				// On Unix systems, use pkill to find remotion processes
+				const { exec } = await import('child_process');
+				exec('pkill -f "remotion.*render"', (error) => {
+					if (!error) {
+						console.log('Cleaned up remaining remotion processes');
+					}
+				});
+			}
+		} catch (e) {
+			// Ignore cleanup errors
+			console.log('Cleanup attempt completed');
+		}
+	};
+
+	// Function to verify if process is actually terminated
+	const verifyProcessTerminated = async (pid) => {
+		try {
+			if (platform() === 'win32') {
+				const { execSync } = await import('child_process');
+				const result = execSync(`tasklist /fi "pid eq ${pid}"`, { encoding: 'utf8' });
+				return !result.includes(pid.toString());
+			} else {
+				// On Unix, sending signal 0 checks if process exists
+				process.kill(pid, 0);
+				return false; // If no error thrown, process still exists
+			}
+		} catch (e) {
+			// If error thrown, process doesn't exist
+			return true;
+		}
+	};
 
 	if (controller && controller.stop) {
-		controller.stop = () => {
+		controller.stop = async () => {
 			console.log('Stopping render studio cli process');
-			if (isProcessKilled || !childProcess.pid) {
-				console.log('Process already terminated or no PID available');
+			if (isProcessKilled) {
+				console.log('Process already terminated');
+				return;
+			}
+
+			isProcessKilled = true;
+
+			if (!childProcess.pid) {
+				console.log('No PID available');
 				return;
 			}
 
 			try {
-				// First try to kill the child process directly
-				if (!childProcess.killed) {
-					childProcess.kill('SIGTERM');
-					isProcessKilled = true;
-					console.log('Process terminated with SIGTERM');
-				}
+				console.log(`Attempting to kill process tree with PID: ${childProcess.pid}`);
 
-				// If detached, also try to kill the process group
-				if (spawnOptions.detached) {
-					setTimeout(() => {
-						try {
-							if (childProcess.pid) {
-								process.kill(-childProcess.pid, 'SIGKILL');
-								console.log('Process group killed with SIGKILL');
-							}
-						} catch (e) {
-							// Ignore ESRCH errors - process already dead
-							if (e.code !== 'ESRCH') {
-								console.error('Failed to kill process group:', e.message);
+				// Kill the entire process tree
+				await killProcessTree(childProcess.pid, 'SIGTERM');
+
+				// Give it a moment to terminate gracefully
+				setTimeout(async () => {
+					const isTerminated = await verifyProcessTerminated(childProcess.pid);
+					if (!childProcess.killed && !isTerminated) {
+						console.log('Process still running, trying SIGKILL');
+						await killProcessTree(childProcess.pid, 'SIGKILL');
+
+						// Final verification and cleanup attempt
+						setTimeout(async () => {
+							const isFinallyTerminated = await verifyProcessTerminated(childProcess.pid);
+							if (!isFinallyTerminated) {
+								console.log('Process still exists after SIGKILL, attempting additional cleanup');
+								await killRemainingRemotionProcesses();
+							} else {
+								console.log('Process successfully terminated');
 							}
-						}
-					}, 1000);
-				}
+						}, 1000);
+					} else {
+						console.log('Process terminated successfully with SIGTERM');
+					}
+				}, 2000); console.log('Process termination initiated');
 			} catch (e) {
-				// Ignore ESRCH errors - process already dead
-				if (e.code !== 'ESRCH') {
-					console.error('Failed to kill process:', e.message);
-				}
+				console.error('Failed to stop process:', e.message);
+				// Try cleanup as fallback
+				await killRemainingRemotionProcesses();
 			}
 		}
 	}
 
 	console.log('Starting video render. ' + cmd);
+	console.log(`Spawned process with PID: ${childProcess.pid}`);
+
+	// Store the process for cleanup
+	processTreePids.add(childProcess.pid);
+
 	let updateCounter = 0;
 	childProcess.stdout.on('data', (data) => {
 		sendToObserver(jobId, data);
@@ -166,27 +274,38 @@ export async function doRender(
 	});
 
 	return new Promise((resolve, reject) => {
-		childProcess.on('close', (code) => {
+		childProcess.on('close', (code, signal) => {
 			isProcessKilled = true; // Mark process as terminated
-			console.log('Render video finished');
+			console.log(`Render process closed with code: ${code}, signal: ${signal}`);
+
+			// Clean up tracked PIDs
+			processTreePids.clear();
+
 			sendToObserver(jobId, code === 0 ? 'completed' : 'failed');
 			if (code === 0) {
 				resolve(outFile);
 				console.log(`'${target}' completed successfully.`);
 			} else {
-				reject({
-					message: `'${target}' failed with code ${code}.`,
-				});
-				console.error(`'${target}' failed with code ${code}.`);
+				const message = signal === 'SIGTERM' || signal === 'SIGKILL' ?
+					`'${target}' was terminated by user request.` :
+					`'${target}' failed with code ${code}.`;
+				reject({ message });
+				console.error(message);
 			}
 		});
 
 		childProcess.on('error', (error) => {
 			isProcessKilled = true; // Mark process as terminated
+			processTreePids.clear();
 			console.error('Child process error:', error);
 			sendToObserver(jobId, 'failed');
 			reject(error);
 		});
+
+		// Handle process exit
+		childProcess.on('exit', (code, signal) => {
+			console.log(`Render process exited with code: ${code}, signal: ${signal}`);
+		});
 	});
 }