fix(sftp): cancel independent uploads without stopping siblings

application/state/sftp/externalUploadRuntime.test.ts

@@ -1,7 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { UploadController } from "../../../lib/uploadService";
+import { UploadController, uploadEntriesDirect } from "../../../lib/uploadService";
 import {
   cancelExternalUploadRuntime,
   getExternalUploadController,
@@ -37,3 +37,64 @@ test("external upload controls survive their originating panel unmount", async (
   assert.equal(getExternalUploadController("folder-1"), undefined);
   assert.equal(getExternalUploadController("child-1"), undefined);
 });
+
+for (const selectedFile of ["a.bin", "c.bin"]) {
+  test(`cancelling independent ${selectedFile} preserves its active and queued upload siblings`, async (t) => {
+    resetExternalUploadRuntimeForTests();
+    t.after(resetExternalUploadRuntimeForTests);
+    const controller = new UploadController();
+    const cancelled: string[] = [];
+    const stagedCancelled: string[] = [];
+    const ids = new Map<string, string>();
+    const pending = new Map<string, (cancelled?: boolean) => void>();
+    const started: string[] = [];
+    const upload = uploadEntriesDirect(
+      ["a.bin", "b.bin", "c.bin"].map((name) => ({
+        file: null, relativePath: name, isDirectory: false, localPath: `/local/${name}`, size: 8,
+      })),
+      {
+        targetPath: "/remote", sftpId: "fixture", isLocal: false,
+        fileTransferConcurrency: 2, joinPath: (base, name) => `${base}/${name}`,
+        callbacks: {
+          onTaskCreated: (task) => {
+            ids.set(task.fileName, task.id);
+            registerExternalUploadController(task.id, controller, "file");
+          },
+        },
+        bridge: {
+          mkdirSftp: async () => {},
+          cancelStagedUploadFile: async (id) => { stagedCancelled.push(id); },
+          cancelTransfer: async (id) => { cancelled.push(id); pending.get(id)?.(true); },
+          startStreamTransfer: ({ transferId, sourcePath }) => new Promise((resolve) => {
+            started.push(sourcePath);
+            pending.set(transferId, (cancelled = false) => resolve({ transferId, cancelled }));
+          }),
+        },
+      },
+      controller,
+    );
+    t.after(async () => {
+      await controller.cancel();
+      for (const finish of pending.values()) finish(true);
+      await upload;
+    });
+    await new Promise(setImmediate);
+    assert.deepEqual(started, ["/local/a.bin", "/local/b.bin"]);
+    const selectedId = ids.get(selectedFile)!;
+    await cancelExternalUploadRuntime(selectedId);
+    assert.deepEqual(cancelled, [selectedId]);
+    assert.deepEqual(stagedCancelled, [selectedId]);
+    assert.equal(controller.isCancelled(), false);
+    await new Promise(setImmediate);
+    assert.deepEqual(started, selectedFile === "a.bin"
+      ? ["/local/a.bin", "/local/b.bin", "/local/c.bin"]
+      : ["/local/a.bin", "/local/b.bin"]);
+    for (const [id, finish] of pending) if (id !== selectedId) finish();
+    const results = (await upload).sort((a, b) => a.fileName.localeCompare(b.fileName));
+    assert.deepEqual(results, ["a.bin", "b.bin", "c.bin"].map((fileName) => (
+      fileName === selectedFile
+        ? { fileName, success: false, cancelled: true }
+        : { fileName, success: true }
+    )));
+  });
+}

application/state/sftp/externalUploadRuntime.ts

@@ -5,11 +5,13 @@ import type { UploadController } from "../../../lib/uploadService";
 // terminal only removes the view; the global transfer runtime can still cancel
 // the upload, and the upload's own finally block releases these entries.
 const controllersByTaskId = new Map<string, UploadController>();
+const scopesByTaskId = new Map<string, "file" | "batch">();
 const taskIdsByController = new Map<UploadController, Set<string>>();
 
 export function registerExternalUploadController(
   taskId: string,
   controller: UploadController,
+  scope: "file" | "batch" = "batch",
 ): void {
   if (!taskId) return;
   const previous = controllersByTaskId.get(taskId);
@@ -19,6 +21,7 @@ export function registerExternalUploadController(
     if (previousIds?.size === 0) taskIdsByController.delete(previous);
   }
   controllersByTaskId.set(taskId, controller);
+  scopesByTaskId.set(taskId, scope);
   const taskIds = taskIdsByController.get(controller) ?? new Set<string>();
   taskIds.add(taskId);
   taskIdsByController.set(controller, taskIds);
@@ -30,6 +33,7 @@ export function unregisterExternalUploadController(controller: UploadController)
   for (const taskId of taskIds) {
     if (controllersByTaskId.get(taskId) === controller) {
       controllersByTaskId.delete(taskId);
+      scopesByTaskId.delete(taskId);
     }
   }
   taskIdsByController.delete(controller);
@@ -40,6 +44,10 @@ export function getExternalUploadController(taskId: string): UploadController |
 }
 
 export async function cancelExternalUploadRuntime(taskId?: string): Promise<boolean> {
+  if (taskId && scopesByTaskId.get(taskId) === "file") {
+    await controllersByTaskId.get(taskId)?.cancelFile(taskId);
+    return true;
+  }
   const controllers = taskId
     ? [controllersByTaskId.get(taskId)].filter((value): value is UploadController => !!value)
     : [...taskIdsByController.keys()];
@@ -50,5 +58,6 @@ export async function cancelExternalUploadRuntime(taskId?: string): Promise<bool
 
 export function resetExternalUploadRuntimeForTests(): void {
   controllersByTaskId.clear();
+  scopesByTaskId.clear();
   taskIdsByController.clear();
 }

application/state/sftp/useSftpExternalOperations.ts

@@ -201,8 +201,8 @@ export const useSftpExternalOperations = (
     return { sftpId, release: () => {} };
   }, [ensureRemoteSftpId, getActivePane, getPaneByConnectionId, getPaneByTabId, getSideByTabId, sftpSessionsRef]);
 
-  const registerUploadController = useCallback((taskId: string, controller: UploadController) => {
-    registerExternalUploadController(taskId, controller);
+  const registerUploadController = useCallback((taskId: string, controller: UploadController, scope: "file" | "batch" = "batch") => {
+    registerExternalUploadController(taskId, controller, scope);
   }, []);
 
   const unregisterUploadController = useCallback((controller: UploadController) => {
@@ -222,7 +222,7 @@ export const useSftpExternalOperations = (
       callbacks.onScanningProgress?.(taskId, progress);
     },
     onTaskCreated: (task) => {
-      registerUploadController(task.id, controller);
+      registerUploadController(task.id, controller, !task.isDirectory && !task.parentTaskId ? "file" : "batch");
       if (task.parentTaskId) {
         registerUploadController(task.parentTaskId, controller);
       }

lib/uploadController.ts

@@ -2,6 +2,7 @@ import type { UploadBridge } from "./uploadService.types";
 
 export class UploadController {
   private cancelled = false;
+  private cancelledFileIds = new Set<string>();
   private activeFileTransferIds = new Set<string>();
   private activeCompressionIds = new Set<string>();
   private currentTransferId = "";
@@ -47,16 +48,7 @@ export class UploadController {
     // Cancel all active file uploads
     const activeIds = Array.from(this.activeFileTransferIds);
     for (const transferId of activeIds) {
-      try {
-        if (this.bridge?.cancelStagedUploadFile) {
-          await this.bridge.cancelStagedUploadFile(transferId);
-        }
-        if (this.bridge?.cancelTransfer) {
-          await this.bridge.cancelTransfer(transferId);
-        }
-      } catch {
-        // Ignore cancel errors
-      }
+      await this.cancelFile(transferId);
     }
 
     // Also cancel current one if not in the set
@@ -71,11 +63,22 @@ export class UploadController {
     }
   }
 
+  /** Cancel one standalone file without stopping the shared upload queue. */
+  async cancelFile(transferId: string): Promise<void> {
+    this.cancelledFileIds.add(transferId);
+    try {
+      await this.bridge?.cancelStagedUploadFile?.(transferId);
+      await this.bridge?.cancelTransfer?.(transferId);
+    } catch {
+      // The transfer runtime reconciles backend cancellation failures.
+    }
+  }
+
   /**
    * Check if upload was cancelled
    */
-  isCancelled(): boolean {
-    return this.cancelled;
+  isCancelled(fileId?: string): boolean {
+    return this.cancelled || (!!fileId && this.cancelledFileIds.has(fileId));
   }
 
   /**
@@ -98,6 +101,7 @@ export class UploadController {
    */
   reset(): void {
     this.cancelled = false;
+    this.cancelledFileIds.clear();
     this.cancelListeners.clear();
     this.activeFileTransferIds.clear();
     this.activeCompressionIds.clear();

lib/uploadService.ts

@@ -769,6 +769,7 @@ async function uploadEntries(
     standaloneTransferId: string,
     fileTotalBytes: number,
   ): Promise<{ cancelled?: boolean; error?: string }> => {
+    if (controller?.isCancelled(standaloneTransferId)) return { cancelled: true };
     let localFilePath = getDropEntryLocalPath(entry);
     let ownedTempPath: string | undefined;
 
@@ -784,13 +785,13 @@ async function uploadEntries(
         ownedTempPath = await bridge.stageUploadFile(entry.file, standaloneTransferId);
       } catch (error) {
         controller?.removeActiveTransfer(standaloneTransferId);
-        if (controller?.isCancelled() || /cancel/i.test(error instanceof Error ? error.message : String(error))) {
+        if (controller?.isCancelled(standaloneTransferId) || /cancel/i.test(error instanceof Error ? error.message : String(error))) {
           return { cancelled: true };
         }
         throw error;
       }
       localFilePath = ownedTempPath;
-      if (controller?.isCancelled()) {
+      if (controller?.isCancelled(standaloneTransferId)) {
         await bridge.deleteTempFile(ownedTempPath).catch(() => {});
         return { cancelled: true };
       }
@@ -956,6 +957,11 @@ async function uploadEntries(
           );
 
           if (uploadResult.cancelled) {
+            if (!bundleTaskId && !controller?.isCancelled()) {
+              settleFileTask(standaloneTransferId, lifecycleManaged, (taskId) => callbacks?.onTaskCancelled?.(taskId));
+              results.push({ fileName: entry.relativePath, success: false, cancelled: true });
+              continue;
+            }
             wasCancelled = true;
             settleFileTask(bundledChildTaskId, lifecycleManaged, (taskId) => callbacks?.onTaskCancelled?.(taskId));
             settleTask(bundleTaskId ?? "", (taskId) => callbacks?.onTaskCancelled?.(taskId));