1.4.6

phantomptr · phantomptr · commit dab3ee6687db · 2026-02-07T23:59:28.000-08:00
diff --git a/Makefile b/Makefile
@@ -217,7 +217,19 @@ test-desktop: setup-desktop
 
 run-desktop: setup-desktop
 	@echo "Starting PS5 Upload desktop app..."
-	@cd desktop && npm run dev
+	@if [ -z "$$DISPLAY" ] && [ -z "$$WAYLAND_DISPLAY" ]; then \
+		if command -v xvfb-run >/dev/null 2>&1; then \
+			echo "No display detected, using xvfb-run..."; \
+			cd desktop && xvfb-run --auto-servernum npm run dev; \
+		else \
+			echo "ERROR: No display server found ($$DISPLAY / $$WAYLAND_DISPLAY not set)."; \
+			echo "  Install xvfb to run headless: sudo apt-get install -y xvfb"; \
+			echo "  Or run this on a machine with a display server."; \
+			exit 1; \
+		fi; \
+	else \
+		cd desktop && npm run dev; \
+	fi
 
 run-app: app
 	@echo "Starting PS5 Upload app service..."
diff --git a/desktop/electron/main.js b/desktop/electron/main.js
@@ -3939,6 +3939,154 @@ async function runPayloadUploadParallelSingleFileV4(file, opts = {}) {
   }));
 }
 
+function readLineFromSocket(socket, timeoutMs = READ_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    let buffer = Buffer.alloc(0);
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      socket.off('data', onData);
+      socket.off('error', onErr);
+      socket.off('close', onClose);
+    };
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error('Read timed out'));
+    }, timeoutMs);
+
+    const onData = (data) => {
+      if (settled) return;
+      buffer = Buffer.concat([buffer, data]);
+      const idx = buffer.indexOf(0x0a);
+      if (idx >= 0) {
+        settled = true;
+        cleanup();
+        resolve(buffer.subarray(0, idx).toString('utf8').trim());
+      }
+    };
+    const onErr = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    const onClose = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      // If we got partial data, return it; otherwise error
+      if (buffer.length > 0) {
+        resolve(buffer.toString('utf8').trim());
+      } else {
+        reject(new Error('Socket closed before response'));
+      }
+    };
+    socket.on('data', onData);
+    socket.on('error', onErr);
+    socket.on('close', onClose);
+  });
+}
+
+async function runPayloadUploadFastMultiFile(files, opts = {}) {
+  const {
+    ip,
+    destPath,
+    connections = 8,
+    cancel = { value: false },
+    chmodAfterUpload = false,
+    onProgress = () => {},
+    log = () => {},
+    onSkipFile,
+  } = opts;
+
+  // Sort files: large files first for better parallelism
+  const sorted = [...files].sort((a, b) => b.size - a.size);
+
+  // Note: No need to pre-create directories — handle_upload_fast_wrapper on
+  // the payload side calls mkdir_p() for each file's parent directory automatically.
+
+  // Connection pool
+  let fileIndex = 0;
+  let totalSent = 0;
+  let completedFiles = 0;
+
+  const uploadOneFile = async (file, idx) => {
+    const socket = await createSocketWithTimeout(ip, TRANSFER_PORT);
+    tuneUploadSocket(socket);
+
+    try {
+      const chmodToken = chmodAfterUpload ? 'CHMOD_END' : '0';
+      const cmd = `UPLOAD_FAST ${escapeCommandPath(destPath)} ${escapeCommandPath(file.rel_path)} ${file.size} DIRECT ${chmodToken}\n`;
+      socket.write(cmd);
+
+      // Wait for READY
+      const response = await readLineFromSocket(socket, READ_TIMEOUT_MS);
+      if (!response.startsWith('READY')) {
+        throw new Error(`Upload rejected: ${response}`);
+      }
+
+      // Stream file data with 8MB buffer
+      if (file.size > 0) {
+        const fd = await fs.promises.open(file.abs_path, 'r');
+        try {
+          const ioBuf = Buffer.allocUnsafe(8 * 1024 * 1024);
+          let remaining = file.size;
+          let pos = 0;
+          while (remaining > 0) {
+            if (cancel.value) throw new Error('Upload cancelled');
+            const take = Math.min(ioBuf.length, remaining);
+            const { bytesRead } = await fd.read(ioBuf, 0, take, pos);
+            if (bytesRead <= 0) throw new Error('Read failed');
+            await writeAllRetry(socket, ioBuf.subarray(0, bytesRead), cancel, log);
+            remaining -= bytesRead;
+            pos += bytesRead;
+            totalSent += bytesRead;
+            onProgress(totalSent, completedFiles, file.rel_path);
+          }
+        } finally {
+          await fd.close().catch(() => {});
+        }
+      }
+
+      // Wait for OK
+      const result = await readLineFromSocket(socket, READ_TIMEOUT_MS);
+      if (!result.startsWith('OK')) {
+        throw new Error(`Upload failed: ${result}`);
+      }
+      completedFiles++;
+    } finally {
+      try { socket.destroy(); } catch {}
+    }
+  };
+
+  // Run workers - each worker takes next file from queue
+  const workers = [];
+  for (let w = 0; w < Math.min(connections, sorted.length); w++) {
+    workers.push((async () => {
+      while (true) {
+        const idx = fileIndex++;
+        if (idx >= sorted.length) break;
+        if (cancel.value) break;
+        const file = sorted[idx];
+        try {
+          await uploadOneFile(file, idx);
+        } catch (err) {
+          if (err.code === 'ENOENT' || err.code === 'EACCES') {
+            log(`Skipping: ${file.rel_path}`);
+            if (typeof onSkipFile === 'function') onSkipFile(file, err);
+            continue;
+          }
+          throw err;
+        }
+      }
+    })());
+  }
+
+  await Promise.all(workers);
+}
+
 async function runPayloadUploadMadMaxSingleFile(file, opts = {}) {
   const {
     ip,
@@ -7630,29 +7778,59 @@ const emitLog = (message, level = 'info', force = false) => {
                         },
                       });
                     } else {
-                      emitLog(`Payload parallel mode: ${effectivePayloadConnections} workers.`, 'info');
-                      state.transferStatus = {
-                        ...state.transferStatus,
-                        payload_transfer_path: 'parallel_files',
-                        payload_workers: effectivePayloadConnections,
-                      };
-                      await runPayloadUploadParallelFiles(attemptFiles, {
-                        connections: effectivePayloadConnections,
-                        uploadInit,
-                        cancel: { get value() { return state.transferCancel; } },
-                        compression: effectiveCompression,
-                        rateLimitBps,
-                        packLimitBytes: basePackLimit,
-                        streamChunkBytes: baseChunkSize,
-                        extraPaceMs,
-                        onSkipFile: (file) => missingFiles.add(file.rel_path),
-                        log: debugLog,
-                        onProgress: (sent, filesSent, currentFile) => {
-                          payloadSent = BigInt(sent);
-                          payloadFilesSent = filesSent;
-                          updateProgress(currentFile);
-                        },
-                      });
+                      // Try fast per-file UPLOAD_FAST path first (no pack overhead)
+                      try {
+                        emitLog(`Payload fast multi-file mode: ${effectivePayloadConnections} workers.`, 'info');
+                        state.transferStatus = {
+                          ...state.transferStatus,
+                          payload_transfer_path: 'fast_multi_file',
+                          payload_workers: effectivePayloadConnections,
+                        };
+                        await runPayloadUploadFastMultiFile(attemptFiles, {
+                          ip: req.ip,
+                          destPath: req.dest_path,
+                          connections: effectivePayloadConnections,
+                          cancel: { get value() { return state.transferCancel; } },
+                          chmodAfterUpload: !!req.chmod_after_upload,
+                          onSkipFile: (file) => missingFiles.add(file.rel_path),
+                          log: debugLog,
+                          onProgress: (sent, filesSent, currentFile) => {
+                            payloadSent = BigInt(sent);
+                            payloadFilesSent = filesSent;
+                            updateProgress(currentFile);
+                          },
+                        });
+                      } catch (fastErr) {
+                        // Fall back to V4 pack path if UPLOAD_FAST is unsupported
+                        if (fastErr?.message?.includes('PAYLOAD_UNSUPPORTED') ||
+                            fastErr?.message?.includes('Unknown command')) {
+                          emitLog(`Fast multi-file not supported, falling back to V4 parallel mode.`, 'warn');
+                          state.transferStatus = {
+                            ...state.transferStatus,
+                            payload_transfer_path: 'parallel_files',
+                            payload_workers: effectivePayloadConnections,
+                          };
+                          await runPayloadUploadParallelFiles(attemptFiles, {
+                            connections: effectivePayloadConnections,
+                            uploadInit,
+                            cancel: { get value() { return state.transferCancel; } },
+                            compression: effectiveCompression,
+                            rateLimitBps,
+                            packLimitBytes: basePackLimit,
+                            streamChunkBytes: baseChunkSize,
+                            extraPaceMs,
+                            onSkipFile: (file) => missingFiles.add(file.rel_path),
+                            log: debugLog,
+                            onProgress: (sent, filesSent, currentFile) => {
+                              payloadSent = BigInt(sent);
+                              payloadFilesSent = filesSent;
+                              updateProgress(currentFile);
+                            },
+                          });
+                        } else {
+                          throw fastErr;
+                        }
+                      }
                     }
                     parsed = { files: payloadFilesSent || attemptFiles.length, bytes: Number(payloadSent) };
                     return;
diff --git a/payload/config.h b/payload/config.h
@@ -5,7 +5,7 @@
 
 // Network settings
 #define SERVER_PORT 9113
-#define MAX_CONNECTIONS 12
+#define MAX_CONNECTIONS 32
 #define RECV_TIMEOUT_SEC 300  // 5 minutes
 
 // Buffer sizes - optimized for high throughput
diff --git a/payload/protocol.c b/payload/protocol.c
@@ -2589,6 +2589,17 @@ void handle_upload_fast_wrapper(int client_sock, const char *args) {
         return;
     }
 
+    // Pre-allocate large files to reduce fragmentation (like PS5-Upload-Suite for >100MB)
+    if (total_size > 100 * 1024 * 1024) {
+        if (ftruncate(fd, (off_t)total_size) != 0) {
+            close(fd);
+            char error[256];
+            snprintf(error, sizeof(error), "ERROR: ftruncate failed: %s\n", strerror(errno));
+            send(client_sock, error, strlen(error), 0);
+            return;
+        }
+    }
+
     const char *ready = "READY\n";
     if (send_all(client_sock, ready, strlen(ready)) != 0) {
         close(fd);
