fix: address CodeRabbit review feedback

- Reject requests exceeding 500 runs with 400 instead of silently truncating
- Propagate finalizeRun through bulk action params so large batches also skip PENDING_CANCEL
- Inherit parent process.env when spawning watchdog (TLS/proxy settings)
- Add PID file prefix (trigger-watchdog:) to prevent killing unrelated processes on PID reuse

Author: ericallam

apps/webapp/app/routes/engine.v1.dev.disconnect.ts

@@ -46,8 +46,14 @@ const { action } = createActionApiRoute(
       );
     }
 
-    // Cap the number of runs
-    const runFriendlyIds = body.runFriendlyIds.slice(0, MAX_RUNS);
+    if (body.runFriendlyIds.length > MAX_RUNS) {
+      return json(
+        { error: `A maximum of ${MAX_RUNS} runs can be cancelled per request` },
+        { status: 400 }
+      );
+    }
+
+    const { runFriendlyIds } = body;
 
     if (runFriendlyIds.length === 0) {
       return json({ cancelled: 0 }, { status: 200 });
@@ -56,7 +62,6 @@ const { action } = createActionApiRoute(
     logger.info("Dev disconnect: cancelling runs", {
       environmentId,
       runCount: runFriendlyIds.length,
-      capped: body.runFriendlyIds.length > MAX_RUNS,
     });
 
     // For small numbers of runs, cancel inline
@@ -150,7 +155,7 @@ async function createBulkCancelAction(
       environmentId,
       name: "Dev session disconnect",
       type: BulkActionType.CANCEL,
-      params: { runId: runFriendlyIds },
+      params: { runId: runFriendlyIds, finalizeRun: true },
       queryName: "bulk_action_v1",
       totalCount: runFriendlyIds.length,
       completionNotification: BulkActionNotificationType.NONE,

apps/webapp/app/v3/services/bulk/BulkActionV2.server.ts

@@ -138,11 +138,13 @@ export class BulkActionService extends BaseService {
     }
 
     // 2. Parse the params
+    const rawParams = group.params && typeof group.params === "object" ? group.params : {};
+    const finalizeRun = "finalizeRun" in rawParams && (rawParams as any).finalizeRun === true;
     const filters = parseRunListInputOptions({
       organizationId: group.project.organizationId,
       projectId: group.projectId,
       environmentId: group.environmentId,
-      ...(group.params && typeof group.params === "object" ? group.params : {}),
+      ...rawParams,
     });
 
     const runsRepository = new RunsRepository({
@@ -199,6 +201,7 @@ export class BulkActionService extends BaseService {
               cancelService.call(run, {
                 reason: `Bulk action ${group.friendlyId} cancelled run`,
                 bulkActionId: bulkActionId,
+                finalizeRun,
               })
             );
             if (error) {

packages/cli-v3/src/dev/devSupervisor.ts

@@ -222,6 +222,7 @@ class DevSupervisor implements WorkerRuntime {
         detached: true,
         stdio: "ignore",
         env: {
+          ...process.env,
           WATCHDOG_PARENT_PID: process.pid.toString(),
           WATCHDOG_API_URL: this.options.client.apiURL,
           WATCHDOG_API_KEY: this.options.client.accessToken ?? "",
@@ -254,8 +255,12 @@ class DevSupervisor implements WorkerRuntime {
     // Also try via PID file in case the process reference is stale
     if (this.watchdogPidPath) {
       try {
-        const pid = parseInt(readFileSync(this.watchdogPidPath, "utf8"), 10);
-        process.kill(pid, "SIGTERM");
+        const content = readFileSync(this.watchdogPidPath, "utf8");
+        const prefix = "trigger-watchdog:";
+        if (content.startsWith(prefix)) {
+          const pid = parseInt(content.slice(prefix.length), 10);
+          if (pid) process.kill(pid, "SIGTERM");
+        }
       } catch {
         // Already dead or no file
       }

packages/cli-v3/src/dev/devWatchdog.ts

@@ -43,23 +43,28 @@ if (!existsSync(dir)) {
   mkdirSync(dir, { recursive: true });
 }
 
+const PID_FILE_PREFIX = "trigger-watchdog:";
+
 // Single instance: kill any existing watchdog
 try {
-  const existingPid = parseInt(readFileSync(pidFilePath, "utf8"), 10);
-  if (existingPid && existingPid !== process.pid) {
-    try {
-      process.kill(existingPid, 0); // Check if alive
-      process.kill(existingPid, "SIGTERM"); // Kill it
-    } catch {
-      // Already dead
+  const pidFileContent = readFileSync(pidFilePath, "utf8");
+  if (pidFileContent.startsWith(PID_FILE_PREFIX)) {
+    const existingPid = parseInt(pidFileContent.slice(PID_FILE_PREFIX.length), 10);
+    if (existingPid && existingPid !== process.pid) {
+      try {
+        process.kill(existingPid, 0); // Check if alive
+        process.kill(existingPid, "SIGTERM"); // Kill it
+      } catch {
+        // Already dead
+      }
     }
   }
 } catch {
-  // No PID file
+  // No PID file or invalid format
 }
 
-// Write our PID
-writeFileSync(pidFilePath, process.pid.toString());
+// Write our PID with prefix so we can verify ownership later
+writeFileSync(pidFilePath, `${PID_FILE_PREFIX}${process.pid}`);
 
 function cleanup() {
   try {