fix(filesystem): bound reads and watches without breaking linked files

.github/workflows/filesystem-limits.yml

@@ -0,0 +1,40 @@
+name: Filesystem resource limits
+
+on:
+  push:
+    branches: ['fix/security-filesystem-limits']
+  pull_request:
+    paths:
+      - 'modules/boss-service-filesystem/**'
+      - 'modules/boss-ipc/src/main/proto/boss/ipc/v1/services/filesystem.proto'
+      - 'plugin-platform/plugin-api-ipc/**'
+      - '.github/workflows/filesystem-limits.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  filesystem:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-java@v6.0.0
+        with:
+          distribution: temurin
+          java-version: '17'
+      - uses: gradle/actions/setup-gradle@v6
+      - name: Run filesystem and paging regressions
+        shell: bash
+        run: ./gradlew :boss-service-filesystem:test :plugin-platform:plugin-api-ipc:desktopTest :boss-service-filesystem:ktlintCheck :boss-service-filesystem:detekt :plugin-platform:plugin-api-ipc:ktlintCheck :plugin-platform:plugin-api-ipc:detekt --no-daemon
+      - uses: actions/upload-artifact@v7
+        if: always()
+        with:
+          name: filesystem-limits-${{ matrix.os }}
+          path: |
+            modules/boss-service-filesystem/build/test-results
+            plugin-platform/plugin-api-ipc/build/test-results

modules/boss-ipc/src/main/proto/boss/ipc/v1/services/filesystem.proto

@@ -51,7 +51,7 @@ message ScanDirectoryRequest {
   bool recursive = 2;           // If true, scan subdirectories too
   bool include_hidden = 3;      // If true, include hidden files/dirs (starting with '.')
   repeated string extensions = 4;  // Filter by extension (e.g., "kt", "ts"). Empty = all.
-  int32 max_depth = 5;          // Max recursion depth (0 = no limit)
+  int32 max_depth = 5;          // Requested depth; server caps depth at 64 and scanned entries at 10,000
 }
 
 message ScanDirectoryResponse {
@@ -64,7 +64,7 @@ message ScanDirectoryResponse {
 message ReadFileRequest {
   string path = 1;
   int64 offset_bytes = 2;       // 0 = start
-  int64 max_bytes = 3;          // 0 = read all
+  int64 max_bytes = 3;          // Explicit page size, capped at 1 MiB; 0 = read all or refuse an oversized file
 }
 
 message ReadFileResponse {

modules/boss-service-filesystem/build.gradle.kts

@@ -35,6 +35,7 @@ dependencies {
     implementation(project(":boss-ipc"))
     implementation(libs.kotlinx.coroutines.core)
     implementation(libs.slf4j.api)
+    implementation(libs.jna)
     runtimeOnly(libs.slf4j.simple)
 
     testImplementation(libs.kotlin.test.junit)

modules/boss-service-filesystem/src/main/kotlin/ai/rever/boss/service/filesystem/BoundedDirectoryScan.kt

@@ -0,0 +1,105 @@
+package ai.rever.boss.service.filesystem
+
+import ai.rever.boss.ipc.proto.services.FileEntry
+import ai.rever.boss.ipc.proto.services.ScanDirectoryRequest
+import kotlinx.coroutines.ensureActive
+import java.nio.file.FileVisitResult
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.SimpleFileVisitor
+import java.nio.file.attribute.BasicFileAttributes
+import kotlin.coroutines.CoroutineContext
+
+internal class BoundedDirectoryScan(
+    private val request: ScanDirectoryRequest,
+    private val context: CoroutineContext,
+    private val validateTarget: (String) -> Unit,
+) {
+    private val requestedDepth = if (!request.recursive) 1 else request.maxDepth.takeIf { it > 0 } ?: Int.MAX_VALUE
+    private val depth = requestedDepth.coerceAtMost(FileSystemLimits.SCAN_DEPTH)
+    private val extensions = request.extensionsList.toSet()
+    private val entries = mutableListOf<FileEntry>()
+    private var visited = 0
+    private var responseBytes = 0
+
+    fun scan(root: Path): List<FileEntry> {
+        val target = root.toRealPath()
+        validateTarget(target.toString())
+        Files.walkFileTree(
+            target,
+            emptySet(),
+            depth,
+            object : SimpleFileVisitor<Path>() {
+                override fun preVisitDirectory(
+                    dir: Path,
+                    attrs: BasicFileAttributes,
+                ) = visit(target, root, dir, attrs)
+
+                override fun visitFile(
+                    file: Path,
+                    attrs: BasicFileAttributes,
+                ) = visit(target, root, file, attrs)
+            },
+        )
+        return entries
+    }
+
+    private fun visit(
+        root: Path,
+        visibleRoot: Path,
+        path: Path,
+        attributes: BasicFileAttributes,
+    ): FileVisitResult {
+        context.ensureActive()
+        enforceFileSystemLimit(++visited <= FileSystemLimits.SCAN_ENTRIES, "Directory scan entry limit reached")
+        val name = path.fileName?.toString().orEmpty()
+        return when {
+            path == root -> {
+                FileVisitResult.CONTINUE
+            }
+
+            !request.includeHidden && name.startsWith('.') -> {
+                FileVisitResult.SKIP_SUBTREE
+            }
+
+            else -> {
+                checkDepth(root, path, attributes)
+                if (attributes.isDirectory || extensions.isEmpty() || name.substringAfterLast('.', "") in extensions) {
+                    add(visibleRoot.resolve(root.relativize(path)), attributes)
+                }
+                FileVisitResult.CONTINUE
+            }
+        }
+    }
+
+    private fun checkDepth(
+        root: Path,
+        path: Path,
+        attributes: BasicFileAttributes,
+    ) {
+        if (attributes.isDirectory && requestedDepth > depth && root.relativize(path).nameCount == depth) {
+            Files.newDirectoryStream(path).use {
+                enforceFileSystemLimit(!it.iterator().hasNext(), "Directory scan depth limit reached")
+            }
+        }
+    }
+
+    private fun add(
+        path: Path,
+        attributes: BasicFileAttributes,
+    ) {
+        val entry =
+            FileEntry
+                .newBuilder()
+                .setPath(path.toString())
+                .setName(path.fileName.toString())
+                .setIsDirectory(attributes.isDirectory)
+                .setSizeBytes(if (attributes.isDirectory) 0L else attributes.size())
+                .setModifiedAt(attributes.lastModifiedTime().toMillis())
+                .setIsHidden(path.fileName.toString().startsWith('.'))
+                .build()
+        responseBytes += entry.serializedSize + 8
+        enforceFileSystemLimit(responseBytes <= FileSystemLimits.SCAN_BYTES, "Directory scan response limit reached")
+        entries.add(entry)
+    }
+}

modules/boss-service-filesystem/src/main/kotlin/ai/rever/boss/service/filesystem/FileSystemLimits.kt

@@ -0,0 +1,20 @@
+package ai.rever.boss.service.filesystem
+
+import io.grpc.Status
+
+/** Bounded RPC pages fit below gRPC's default message limit; callers can page large file reads explicitly. */
+internal object FileSystemLimits {
+    const val READ_BYTES = 1_048_576
+    const val SCAN_ENTRIES = 10_000
+    const val SCAN_DEPTH = 64
+    const val SCAN_BYTES = 2_097_152
+}
+
+internal fun fileSystemLimit(message: String) = Status.RESOURCE_EXHAUSTED.withDescription(message).asRuntimeException()
+
+internal fun enforceFileSystemLimit(
+    condition: Boolean,
+    message: String,
+) {
+    if (!condition) throw fileSystemLimit(message)
+}