feat: support Remote Development via Plugin Model V2 content modules

.github/scripts/list-verifier-ides.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Emit the IDEs `verifyPlugin` should target as a compact JSON array.
+
+`recommended()` (resolved by the printProductsReleases task) also returns the
+current EAP, e.g. ["IU-2026.1.3", "IU-262.7581.18"]. We keep only released IDEs:
+EAP builds relocate the @ApiStatus.Internal split-mode classes the client module
+compiles against, so the plugin can't even build there. 2026.2 rejoins the matrix
+automatically once it ships as IU-2026.2.x.
+
+Feeds a GitHub Actions discover job whose output drives a one-runner-per-IDE matrix:
+
+    - id: list
+      run: echo "ides=$(python3 .github/scripts/list-verifier-ides.py)" >> "$GITHUB_OUTPUT"
+"""
+
+import json
+import subprocess
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+
+def is_release(ide: str) -> bool:
+    """A release's leading version is a calendar year (IU-2026.1.3); an EAP's is a
+    build branch number (IU-262.7581.18), which is below 2000."""
+    major = int(ide.split("-")[1].split(".")[0])
+    return major >= 2000
+
+
+def main() -> None:
+    result = subprocess.run(
+        ["./gradlew", "-q", "printProductsReleases"],
+        cwd=REPO_ROOT,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    ides = [line for line in result.stdout.splitlines() if line]
+    # printProductsReleases repeats builds across update channels; one verify run
+    # per unique IDE is enough, and sorting keeps the matrix order stable.
+    releases = sorted({ide for ide in ides if is_release(ide)})
+    print(json.dumps(releases, separators=(",", ":")))
+
+
+if __name__ == "__main__":
+    main()

.github/workflows/build.yml

@@ -258,7 +258,7 @@ jobs:
 
       - name: List verifier IDEs
         id: list
-        run: echo "ides=$(.github/scripts/list-verifier-ides.sh)" >> "$GITHUB_OUTPUT"
+        run: echo "ides=$(python3 .github/scripts/list-verifier-ides.py)" >> "$GITHUB_OUTPUT"
 
   # Run plugin structure verification along with IntelliJ Plugin Verifier.
   # One runner per IDE so a single IDE failure doesn't cascade through the

.gitignore

@@ -6,4 +6,4 @@
 .qodana
 build
 # Generated by `npm run build` in ui/ (vite outDir, emptyOutDir wipes it each build)
-src/main/resources/player/
+frontend/src/main/resources/player/

AGENTS.md

@@ -6,22 +6,23 @@ IntelliJ Platform plugin providing native audio/video playback in JetBrains IDEs
 
 - Kotlin
 - Gradle (Kotlin DSL)
-- IntelliJ Platform SDK (2025.2+)
+- IntelliJ Platform SDK (2025.3+)
 - JCEF (JBCefBrowser) for media rendering
 - JDK 21
 
 ## Project Structure
 
-- `src/main/kotlin/dev/twango/jetplay/` — plugin source
-- `src/main/resources/META-INF/plugin.xml` — plugin descriptor (single source of truth for supported extensions)
+- `shared/`, `frontend/`, `client/`, `backend/` — Plugin Model V2 content modules, each under `<module>/src/main/kotlin/dev/twango/jetplay/`. `shared` (loads everywhere): shared types, RPC contract, i18n bundle. `frontend` (loads on the Remote Dev host **and** client): file type + editor provider + JCEF player + loopback media server; JCEF is guarded off on the host. `client` (JetBrains Client only, binds the platform's `intellij.platform.frontend.split` module): `rdclient.fileEditorModelHandler` that renders the player client-side in split mode. `backend` (host): ffmpeg + RPC byte/transcode access.
+- `src/main/resources/META-INF/plugin.xml` — root plugin descriptor (content-module wiring only)
+- `frontend/src/main/resources/dev.twango.jetplay.frontend.xml` — frontend module descriptor; single source of truth for supported extensions. The `frontend` module loads on both host and client, so its `fileType`/`fileEditorProvider` register on the host (for detection/selection) while the JCEF player renders on the client.
 - `gradle.properties` — plugin metadata and version config
 
 ## Conventions
 
 - Follow IntelliJ Platform plugin conventions and API patterns
 - Use `FileEditorProvider` / `FileEditor` for registering custom editors
 - Keep the plugin lightweight — no unnecessary services or actions
-- Supported extensions are defined in `plugin.xml`, not hardcoded in Kotlin
+- Supported extensions are defined in the frontend module descriptor (`dev.twango.jetplay.frontend.xml`), not hardcoded in Kotlin
 
 ## Build
 

backend/build.gradle.kts

@@ -0,0 +1,48 @@
+import org.jetbrains.intellij.platform.gradle.TestFrameworkType
+
+dependencies {
+    intellijPlatform {
+        bundledModule("intellij.platform.kernel.backend")
+        bundledModule("intellij.platform.rpc")
+        bundledModule("intellij.platform.rpc.backend")
+        bundledModule("intellij.platform.backend")
+        compileOnly(libs.kotlin.serialization.core.jvm)
+        compileOnly(libs.kotlin.serialization.json.jvm)
+        testFramework(TestFrameworkType.Platform)
+    }
+    implementation(project(":shared"))
+
+    testImplementation(libs.junit)
+    testImplementation(libs.opentest4j)
+
+    implementation("org.bytedeco:javacv:1.5.13") {
+        exclude(group = "org.bytedeco", module = "opencv")
+        exclude(group = "org.bytedeco", module = "openblas")
+        exclude(group = "org.bytedeco", module = "flycapture")
+        exclude(group = "org.bytedeco", module = "libdc1394")
+        exclude(group = "org.bytedeco", module = "libfreenect")
+        exclude(group = "org.bytedeco", module = "libfreenect2")
+        exclude(group = "org.bytedeco", module = "librealsense")
+        exclude(group = "org.bytedeco", module = "librealsense2")
+        exclude(group = "org.bytedeco", module = "videoinput")
+        exclude(group = "org.bytedeco", module = "artoolkitplus")
+        exclude(group = "org.bytedeco", module = "flandmark")
+        exclude(group = "org.bytedeco", module = "leptonica")
+        exclude(group = "org.bytedeco", module = "tesseract")
+    }
+    implementation("org.bytedeco:ffmpeg:7.1-1.5.13:linux-x86_64")
+    implementation("org.bytedeco:ffmpeg:7.1-1.5.13:macosx-x86_64")
+    implementation("org.bytedeco:ffmpeg:7.1-1.5.13:macosx-arm64")
+    implementation("org.bytedeco:ffmpeg:7.1-1.5.13:windows-x86_64")
+    implementation("org.bytedeco:javacpp:1.5.13:linux-x86_64")
+    implementation("org.bytedeco:javacpp:1.5.13:macosx-x86_64")
+    implementation("org.bytedeco:javacpp:1.5.13:macosx-arm64")
+    implementation("org.bytedeco:javacpp:1.5.13:windows-x86_64")
+}
+
+// IPGP names the content-module jar "<rootProject>.<module>" (jetplay.backend), but the platform and the
+// plugin verifier resolve content modules by "lib/modules/<moduleId>.jar". Align the jar name with the module
+// id so the descriptor resolves instead of falling back to scanning every bundled jar (incl. javacv).
+tasks.named<org.jetbrains.intellij.platform.gradle.tasks.ComposedJarTask>("composedJar") {
+    archiveBaseName.set("dev.twango.jetplay.backend")
+}

backend/src/main/kotlin/dev/twango/jetplay/rpc/MediaAccessorImpl.kt

@@ -0,0 +1,122 @@
+@file:Suppress("UnstableApiUsage")
+
+package dev.twango.jetplay.rpc
+
+import com.intellij.ide.vfs.VirtualFileId
+import com.intellij.ide.vfs.virtualFile
+import com.intellij.platform.project.ProjectId
+import com.intellij.platform.project.findProjectOrNull
+import dev.twango.jetplay.media.MediaInfo
+import dev.twango.jetplay.transcode.FfmpegAvailability
+import dev.twango.jetplay.transcode.MediaInfoExtractor
+import dev.twango.jetplay.transcode.TranscodeRunner
+import dev.twango.jetplay.transcode.WaveformExtractor
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.RandomAccessFile
+
+private const val CHUNK_BYTES = 1 shl 20 // 1 MB
+
+class MediaAccessorImpl : MediaAccessor {
+
+    // Resolve only within a live project; a dead projectId means a stale RPC caller.
+    private fun resolveFile(fileId: VirtualFileId, projectId: ProjectId): File? {
+        if (projectId.findProjectOrNull() == null) return null
+        return fileId.virtualFile()?.takeIf { it.isValid }?.let { vf ->
+            runCatching { vf.toNioPath().toFile() }.getOrNull()?.takeIf { it.isFile }
+        }
+    }
+
+    override suspend fun streamFileBytes(fileId: VirtualFileId, projectId: ProjectId): Flow<ByteArray> = flow {
+        val file = resolveFile(fileId, projectId) ?: return@flow
+        RandomAccessFile(file, "r").use { raf ->
+            val buf = ByteArray(CHUNK_BYTES)
+            while (true) {
+                val n = raf.read(buf)
+                if (n <= 0) break
+                emit(if (n == buf.size) buf.copyOf() else buf.copyOf(n))
+            }
+        }
+    }.flowOn(Dispatchers.IO)
+
+    override suspend fun fileLength(fileId: VirtualFileId, projectId: ProjectId): Long =
+        withContext(Dispatchers.IO) { resolveFile(fileId, projectId)?.length() ?: -1L }
+
+    override suspend fun readRange(fileId: VirtualFileId, projectId: ProjectId, offset: Long, length: Int): ByteArray =
+        withContext(Dispatchers.IO) {
+            if (offset < 0 || length <= 0) return@withContext ByteArray(0)
+            val file = resolveFile(fileId, projectId) ?: return@withContext ByteArray(0)
+            RandomAccessFile(file, "r").use { raf ->
+                raf.seek(offset)
+                val out = ByteArray(length)
+                // raf.read() may return a short count; loop until full or EOF.
+                var total = 0
+                while (total < length) {
+                    val n = raf.read(out, total, length - total)
+                    if (n < 0) break
+                    total += n
+                }
+                when (total) {
+                    0 -> ByteArray(0)
+                    length -> out
+                    else -> out.copyOf(total)
+                }
+            }
+        }
+
+    override suspend fun transcodeFile(fileId: VirtualFileId, projectId: ProjectId): Flow<TranscodeEvent> =
+        channelFlow {
+            if (!FfmpegAvailability.available) {
+                send(TranscodeEvent.Unavailable)
+                return@channelFlow
+            }
+            val input = resolveFile(fileId, projectId) ?: run {
+                send(TranscodeEvent.Failed("source unavailable"))
+                return@channelFlow
+            }
+            val output = try {
+                withContext(Dispatchers.IO) {
+                    // onProgress fires synchronously inside ffmpeg, so trySend (non-suspending) bridges it.
+                    TranscodeRunner.transcode(input) { pct -> trySend(TranscodeEvent.Progress(pct)) }
+                }
+            } catch (e: Exception) {
+                send(TranscodeEvent.Failed(e.message ?: "unknown"))
+                return@channelFlow
+            }
+            try {
+                withContext(Dispatchers.IO) {
+                    RandomAccessFile(output, "r").use { raf ->
+                        val buf = ByteArray(CHUNK_BYTES)
+                        while (true) {
+                            val n = raf.read(buf)
+                            if (n <= 0) break
+                            send(TranscodeEvent.Chunk(if (n == buf.size) buf.copyOf() else buf.copyOf(n)))
+                        }
+                    }
+                }
+            } finally {
+                // Frontend now holds the bytes; drop the backend copy.
+                runCatching { output.delete() }
+            }
+            send(TranscodeEvent.Done)
+        }
+
+    override suspend fun extractWaveform(fileId: VirtualFileId, projectId: ProjectId): List<Double> =
+        withContext(Dispatchers.IO) {
+            if (!FfmpegAvailability.available) return@withContext emptyList()
+            val file = resolveFile(fileId, projectId) ?: return@withContext emptyList()
+            runCatching { WaveformExtractor.extract(file) }.getOrDefault(emptyList())
+        }
+
+    override suspend fun extractMediaInfo(fileId: VirtualFileId, projectId: ProjectId): MediaInfo? =
+        withContext(Dispatchers.IO) {
+            if (!FfmpegAvailability.available) return@withContext null
+            val file = resolveFile(fileId, projectId) ?: return@withContext null
+            runCatching { MediaInfoExtractor.extract(file) }.getOrNull()
+        }
+}

backend/src/main/kotlin/dev/twango/jetplay/rpc/MediaAccessorProvider.kt

@@ -0,0 +1,12 @@
+@file:Suppress("UnstableApiUsage")
+
+package dev.twango.jetplay.rpc
+
+import com.intellij.platform.rpc.backend.RemoteApiProvider
+import fleet.rpc.remoteApiDescriptor
+
+internal class MediaAccessorProvider : RemoteApiProvider {
+    override fun RemoteApiProvider.Sink.remoteApis() {
+        remoteApi(remoteApiDescriptor<MediaAccessor>()) { MediaAccessorImpl() }
+    }
+}