Stabilize discovery workflow

app/Services/Discovery/NetworkScanner.php

@@ -36,18 +36,76 @@ class NetworkScanner
     /**
      * @return DiscoveredHost[]
      */
-    public function scan(NetworkRange $range): array
+    public function scan(NetworkRange $range, ?int $scanJobId = null): array
+    {
+        $result = $this->scanResumable(
+            $range,
+            $scanJobId ?? 0,
+            0,
+            static fn (): bool => false,
+            static function (array $state): void {
+            }
+        );
+
+        return $result['hosts'];
+    }
+
+    /**
+     * @return array{hosts: DiscoveredHost[], completed: bool, next_ip_index: int, total_ips: int, scanned_count: int, hosts_found: int}
+     */
+    public function scanResumable(
+        NetworkRange $range,
+        int $scanJobId,
+        int $startIndex,
+        callable $shouldStop,
+        callable $onProgress
+    ): array
     {
         $ips = $this->enumerateIps($range->cidr);
         $aliveHosts = [];
+        $scannedCount = 0;
+        $nextIndex = max(0, $startIndex);
+        $arpEntries = $this->arpTableReader->read();
+
+        $onProgress([
+            'next_ip_index' => $nextIndex,
+            'total_ips' => count($ips),
+            'scanned_count' => $scannedCount,
+            'hosts_found' => count($aliveHosts),
+        ]);
+
+        foreach ($ips as $index => $ip) {
+            if ($index < $nextIndex) {
+                continue;
+            }
+
+            if ($shouldStop()) {
+                return [
+                    'hosts' => $aliveHosts,
+                    'completed' => false,
+                    'next_ip_index' => $index,
+                    'total_ips' => count($ips),
+                    'scanned_count' => $scannedCount,
+                    'hosts_found' => count($aliveHosts),
+                ];
+            }
+
+            $nextIndex = $index + 1;
+            $scannedCount++;
 
-        foreach ($ips as $ip) {
             // Step 1: Ping sweep
             if (!$this->pingScanner->ping($ip)) {
+                $onProgress([
+                    'next_ip_index' => $nextIndex,
+                    'total_ips' => count($ips),
+                    'scanned_count' => $scannedCount,
+                    'hosts_found' => count($aliveHosts),
+                ]);
                 continue;
             }
 
             $host = new DiscoveredHost();
+            $host->scanJobId = $scanJobId > 0 ? $scanJobId : null;
             $host->ipAddress = $ip;
             $host->firstSeen = new \DateTimeImmutable();
             $host->lastSeen = new \DateTimeImmutable();
@@ -66,20 +124,30 @@ class NetworkScanner
             // Step 5: Confidence score
             $host->confidence = $this->fingerprintService->calculateConfidence(count($openPorts), $hostname !== null);
 
-            $aliveHosts[] = $host;
-        }
-
-        // Step 6: ARP table enrichment
-        $arpEntries = $this->arpTableReader->read();
-        foreach ($aliveHosts as $host) {
             if (isset($arpEntries[$host->ipAddress])) {
                 $host->macAddress = $arpEntries[$host->ipAddress]['mac'] ?? null;
                 $host->vendor = $host->vendor ?: ($arpEntries[$host->ipAddress]['vendor'] ?? null);
             }
+
             $this->discoveredHostRepository->save($host);
+
+            $aliveHosts[] = $host;
+            $onProgress([
+                'next_ip_index' => $nextIndex,
+                'total_ips' => count($ips),
+                'scanned_count' => $scannedCount,
+                'hosts_found' => count($aliveHosts),
+            ]);
         }
 
-        return $aliveHosts;
+        return [
+            'hosts' => $aliveHosts,
+            'completed' => true,
+            'next_ip_index' => $nextIndex,
+            'total_ips' => count($ips),
+            'scanned_count' => $scannedCount,
+            'hosts_found' => count($aliveHosts),
+        ];
     }
 
     /**
@@ -87,31 +155,41 @@ class NetworkScanner
      */
     private function enumerateIps(string $cidr): array
     {
-        if (str_contains($cidr, '/32')) {
-            return [explode('/', $cidr)[0]];
+        if (!preg_match('#^(\d+\.\d+\.\d+\.\d+)/(\d{1,2})$#', $cidr, $matches)) {
+            throw new \InvalidArgumentException("Invalid IPv4 CIDR: {$cidr}");
         }
 
-        // Only handle /24 or larger for MVP (to avoid scanning huge ranges)
-        if (preg_match('#^(\d+\.\d+\.\d+)\.(\d+)/(\d+)$#', $cidr, $m)) {
-            $prefix = $m[1];
-            $suffix = (int)$m[2];
-            $mask = (int)$m[3];
-
-            if ($mask > 24) {
-                // Treat smaller than /24 as single IP
-                return [$cidr];
-            }
-
-            $offset = $mask === 24 ? 0 : $suffix;
-            $count = 2 ** (24 - $mask);
-            $ips = [];
-            for ($i = 1; $i <= $count; $i++) {
-                $ips[] = $prefix . '.' . ($offset + $i);
-            }
-            return $ips;
+        $baseIp = $matches[1];
+        $mask = (int)$matches[2];
+        if ($mask < 24) {
+            throw new \InvalidArgumentException('Network ranges larger than /24 are disabled for the MVP scanner');
+        }
+        if ($mask > 32) {
+            throw new \InvalidArgumentException("Invalid IPv4 CIDR mask: {$cidr}");
         }
 
-        return [];
+        $base = ip2long($baseIp);
+        if ($base === false) {
+            throw new \InvalidArgumentException("Invalid IPv4 address: {$baseIp}");
+        }
+
+        $base = (int)sprintf('%u', $base);
+        $hostCount = 2 ** (32 - $mask);
+        $network = $base & ((0xFFFFFFFF << (32 - $mask)) & 0xFFFFFFFF);
+
+        if ($mask === 32) {
+            return [long2ip($network)];
+        }
+
+        $start = $mask === 31 ? $network : $network + 1;
+        $end = $mask === 31 ? $network + 1 : $network + $hostCount - 2;
+
+        $ips = [];
+        for ($ip = $start; $ip <= $end; $ip++) {
+            $ips[] = long2ip($ip);
+        }
+
+        return $ips;
     }
 
     private function resolveHostname(string $ip): ?string