release: v1.15

修复: 备份异常 EPERM (Operation not permitted) 导致整个备份中断
- BackupOperation: 检查 mkdirs 返回值，writeText 异常时优雅降级而非抛出
- BackupScreen: 增加异常完整堆栈记录和智能提示（EPERM/EACCES）

.omp/lsp.json

@@ -0,0 +1,12 @@
+{
+  "servers": {
+    "kotlin-lsp": {
+      "command": "kotlin-language-server",
+      "args": [],
+      "fileTypes": [".kt", ".kts"],
+      "rootMarkers": ["build.gradle", "settings.gradle"],
+      "warmupTimeoutMs": 60000
+    }
+  },
+  "idleTimeoutMs": 600000
+}

AGENTS.md

@@ -1,7 +1,7 @@
 <!-- gitnexus:start -->
 # GitNexus — Code Intelligence
 
-This project is indexed by GitNexus as **android-backup-gui** (1614 symbols, 4022 relationships, 139 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+This project is indexed by GitNexus as **android-backup-gui** (1684 symbols, 4068 relationships, 146 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
 
 > If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first.
 

CLAUDE.md

@@ -1,7 +1,7 @@
 <!-- gitnexus:start -->
 # GitNexus — Code Intelligence
 
-This project is indexed by GitNexus as **android-backup-gui** (1614 symbols, 4022 relationships, 139 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+This project is indexed by GitNexus as **android-backup-gui** (1684 symbols, 4068 relationships, 146 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
 
 > If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first.
 

app/build.gradle

@@ -24,8 +24,8 @@ android {
         applicationId "com.example.androidbackupgui"
         minSdk 24
         targetSdk 34
-        versionCode 14
+        versionCode 15
-        versionName "1.14"
+        versionName "1.15"
     }
     buildFeatures {
         compose = true

app/src/main/java/com/example/androidbackupgui/backup/BackupOperation.kt

@@ -72,16 +72,29 @@ object BackupOperation {
 
         // Create backup structure
         val backupRoot = File(outputDir, "Backup_${config.compressionMethod}_$userId")
-        backupRoot.mkdirs()
+        if (!backupRoot.mkdirs() && !backupRoot.isDirectory) {
+            LogUtil.e(TAG, "backupApps: cannot create output dir ${backupRoot.absolutePath}")
+            return@withContext BackupResult(0, 0, 0, outputDir.absolutePath, 0)
+        }
         LogUtil.i(TAG, "backupApps: starting backup of ${apps.size} apps to ${backupRoot.absolutePath}")
 
         // Write app list — includes ALL packages in [apps] (selected + legacy from snapshot)
         val appListFile = File(backupRoot, "appList.txt")
-        appListFile.writeText(apps.joinToString("\n") { it.packageName.value })
+        try {
+            appListFile.writeText(apps.joinToString("\n") { it.packageName.value })
+        } catch (e: Exception) {
+            LogUtil.e(TAG, "backupApps: failed to write appList.txt — ${e.message}")
+            return@withContext BackupResult(0, 0, 0, outputDir.absolutePath, 0)
+        }
 
         // Write metadata JSON — fresh metadata for selected apps, legacy for historical apps
         val metaFile = File(backupRoot, "app_details.json")
-        metaFile.writeText(buildAppDetailsJson(apps, legacyApps))
+        try {
+            metaFile.writeText(buildAppDetailsJson(apps, legacyApps))
+        } catch (e: Exception) {
+            LogUtil.e(TAG, "backupApps: failed to write app_details.json — ${e.message}")
+            return@withContext BackupResult(0, 0, 0, outputDir.absolutePath, 0)
+        }
 
         val backupTargets = if (includePkgs.isEmpty()) apps else apps.filter { it.packageName.value in includePkgs }
         val totalCount = backupTargets.size
@@ -341,15 +354,23 @@ object BackupOperation {
             ?.substringBefore("\"")
             ?.takeIf { it.isNotBlank() }
         if (value != null) {
-            File(appDir, "ssaid.txt").writeText(value)
+            try {
-            Log.d(TAG, "backupSsaid: backed up SSAID for $packageName = $value")
+                File(appDir, "ssaid.txt").writeText(value)
+                Log.d(TAG, "backupSsaid: backed up SSAID for $packageName = $value")
+            } catch (e: Exception) {
+                Log.w(TAG, "backupSsaid: failed to write ssaid.txt for $packageName", e)
+            }
         }
     }
 
     private suspend fun backupPermissions(packageName: String, appDir: File) {
         val result = RootShell.exec("dumpsys package '${packageName.shellEscape()}' | grep -E 'granted=(true|false)'")
         if (result.output.isNotBlank()) {
-            File(appDir, "permissions.txt").writeText(result.output)
+            try {
+                File(appDir, "permissions.txt").writeText(result.output)
+            } catch (e: Exception) {
+                Log.w(TAG, "backupPermissions: failed to write permissions.txt for $packageName", e)
+            }
         }
     }
 

app/src/main/java/com/example/androidbackupgui/ui/BackupScreen.kt

@@ -3,6 +3,7 @@ package com.example.androidbackupgui.ui
 import android.content.Intent
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
+import android.util.Log
 import androidx.compose.foundation.lazy.items
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.SortByAlpha
@@ -269,8 +270,18 @@ fun BackupScreen() {
                                     }
                                 }
                             } catch (e: Exception) {
-                                statusText = "备份异常: ${e.message}"
+                                val errMsg = e.message ?: "未知错误"
-                            } finally {
+                                Log.e("BackupScreen", "备份异常", e)
+                                val hint = when {
+                                    errMsg.contains("EPERM", ignoreCase = true) || errMsg.contains("Operation not permitted", ignoreCase = true) ->
+                                        "写入备份目录被拒绝，请检查输出路径权限或改用内置存储"
+                                    errMsg.contains("EACCES", ignoreCase = true) || errMsg.contains("Permission denied", ignoreCase = true) ->
+                                        "权限不足，请检查存储权限"
+                                    else -> null
+                                }
+                                statusText = if (hint != null) "备份异常: ${e.message} ($hint)" else "备份异常: ${e.message}"
+                            }
+                            finally {
                                 isRunning = false
                                 try {
                                     val stopIntent = Intent(context, BackupService::class.java).apply {

app/src/main/res/xml/data_extraction_rules.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<data-extraction-rules>
+    <cloud-backup>
+        <include domain="file" path="."/>
+    </cloud-backup>
+    <device-transfer>
+        <include domain="file" path="."/>
+    </device-transfer>
+</data-extraction-rules>

app/src/test/java/android/util/Log.java

@@ -0,0 +1,23 @@
+package android.util;
+
+/**
+ * Test-only stub for android.util.Log.
+ * Prevents RuntimeException("Stub!") from android.jar during JVM unit tests.
+ */
+public final class Log {
+    public static int v(String tag, String msg) { return 0; }
+    public static int v(String tag, String msg, Throwable tr) { return 0; }
+    public static int d(String tag, String msg) { return 0; }
+    public static int d(String tag, String msg, Throwable tr) { return 0; }
+    public static int i(String tag, String msg) { return 0; }
+    public static int i(String tag, String msg, Throwable tr) { return 0; }
+    public static int w(String tag, String msg) { return 0; }
+    public static int w(String tag, String msg, Throwable tr) { return 0; }
+    public static int e(String tag, String msg) { return 0; }
+    public static int e(String tag, String msg, Throwable tr) { return 0; }
+    public static int wtf(String tag, String msg) { return 0; }
+    public static int wtf(String tag, String msg, Throwable tr) { return 0; }
+    public static String getStackTraceString(Throwable tr) { return ""; }
+    public static boolean isLoggable(String tag, int level) { return false; }
+    public static int println(int priority, String tag, String msg) { return 0; }
+}

app/src/test/java/com/example/androidbackupgui/backup/AppErrorTest.kt

@@ -0,0 +1,273 @@
+package com.example.androidbackupgui.backup
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeInstanceOf
+import io.kotest.property.Arb
+import io.kotest.property.arbitrary.int
+import io.kotest.property.arbitrary.string
+import io.kotest.property.checkAll
+import java.io.IOException
+
+class AppErrorTest : FunSpec({
+
+    context("AppError.Network") {
+        test("has correct defaults") {
+            val error = AppError.Network("connection timeout")
+            error.message shouldBe "connection timeout"
+            error.cause.shouldBeNull()
+            error.retryable shouldBe true
+        }
+
+        test("preserves cause and retryable overrides") {
+            val cause = RuntimeException("DNS failed")
+            val error = AppError.Network("DNS resolution failed", cause = cause, retryable = false)
+            error.cause shouldBe cause
+            error.retryable shouldBe false
+        }
+
+        test("property: message is preserved") {
+            checkAll(Arb.string(1..200)) { msg ->
+                val error = AppError.Network(msg)
+                error.message shouldBe msg
+            }
+        }
+    }
+
+    context("AppError.Remote") {
+        test("preserves phase, cause, isNotFound, retryable") {
+            val cause = RuntimeException("underlying error")
+            val error = AppError.Remote("upload failed", "upload", cause = cause)
+            error.message shouldBe "upload failed"
+            error.phase shouldBe "upload"
+            error.cause shouldBe cause
+            error.isNotFound shouldBe false
+            error.retryable shouldBe false
+        }
+
+        test("with isNotFound=true") {
+            val error = AppError.Remote("not found", "list", isNotFound = true)
+            error.isNotFound shouldBe true
+        }
+    }
+
+    context("AppError.Shell") {
+        test("preserves command, exitCode, and stderr") {
+            val error = AppError.Shell("cp failed", "cp /a /b", 1, "permission denied")
+            error.message shouldBe "cp failed"
+            error.command shouldBe "cp /a /b"
+            error.exitCode shouldBe 1
+            error.stderr shouldBe "permission denied"
+        }
+    }
+
+    context("AppError.LocalIO") {
+        test("preserves path and optional cause") {
+            val error = AppError.LocalIO("file not found", "/data/test.txt")
+            error.message shouldBe "file not found"
+            error.path shouldBe "/data/test.txt"
+            error.cause.shouldBeNull()
+        }
+
+        test("preserves cause when provided") {
+            val cause = IOException("disk full")
+            val error = AppError.LocalIO("write failed", "/data/test.txt", cause = cause)
+            error.cause shouldBe cause
+        }
+    }
+
+    context("AppError.Restic") {
+        test("preserves exit code and stderr") {
+            val error = AppError.Restic("restic failed", 1, "permission denied")
+            error.message shouldBe "restic failed"
+            error.exitCode shouldBe 1
+            error.stderr shouldBe "permission denied"
+        }
+
+        test("property: any exit code is preserved") {
+            checkAll(Arb.int()) { code ->
+                val error = AppError.Restic("err", code, "stderr output")
+                error.exitCode shouldBe code
+            }
+        }
+    }
+
+    context("AppError.Parse") {
+        test("preserves message and detail") {
+            val error = AppError.Parse("bad json", "expected '{'")
+            error.message shouldBe "bad json"
+            error.detail shouldBe "expected '{'"
+        }
+
+        test("detail defaults to empty string") {
+            val error = AppError.Parse("bad json")
+            error.detail shouldBe ""
+        }
+    }
+
+    context("AppError.Cancelled") {
+        test("is a data object with fixed message") {
+            val error = AppError.Cancelled
+            error.message shouldBe "操作被取消"
+            // Verify singleton behavior
+            val error2 = AppError.Cancelled
+            error shouldBe error2
+        }
+    }
+
+    context("AppResult.Success") {
+        test("holds a value") {
+            val result: AppResult<String> = AppResult.Success("hello")
+            result.isSuccess shouldBe true
+            result.isFailure shouldBe false
+            result.getOrNull() shouldBe "hello"
+            result.getOrDefault("fallback") shouldBe "hello"
+            result.getOrThrow() shouldBe "hello"
+            result.exceptionOrNull().shouldBeNull()
+            result.errorOrNull().shouldBeNull()
+        }
+
+        test("fold calls onSuccess") {
+            val result: AppResult<Int> = AppResult.Success(42)
+            val folded =
+                result.fold(
+                    onSuccess = { it * 2 },
+                    onFailure = { 0 },
+                )
+            folded shouldBe 84
+        }
+
+        test("map transforms value") {
+            val result: AppResult<Int> = AppResult.Success(42)
+            val mapped = result.map { it.toString() }
+            mapped shouldBe AppResult.Success("42")
+        }
+
+        test("mapError passes through success") {
+            val result: AppResult<Int> = AppResult.Success(42)
+            val mapped = result.mapError { AppError.Parse("should not happen") }
+            mapped shouldBe AppResult.Success(42)
+        }
+    }
+
+    context("AppResult.Failure via err()") {
+        test("creates failure result") {
+            val result: AppResult<String> = err(AppError.Parse("bad json"))
+            result.isSuccess shouldBe false
+            result.isFailure shouldBe true
+            result.getOrNull().shouldBeNull()
+            result.getOrDefault("fallback") shouldBe "fallback"
+            result.errorOrNull() shouldBe AppError.Parse("bad json")
+            result.errorOrNull()?.message shouldBe "bad json"
+        }
+
+        test("exceptionOrNull returns RuntimeException with AppError message") {
+            val result: AppResult<String> = err(AppError.Parse("bad json"))
+            val ex = result.exceptionOrNull()
+            ex.shouldBeInstanceOf<RuntimeException>()
+            ex?.message shouldBe "bad json"
+        }
+
+        test("getOrThrow throws RuntimeException") {
+            val result: AppResult<String> = err(AppError.Parse("bad json"))
+            val ex = shouldThrow<RuntimeException> { result.getOrThrow() }
+            ex.message shouldBe "bad json"
+        }
+
+        test("wraps any AppError subtype") {
+            val errors =
+                listOf(
+                    AppError.Network("net err"),
+                    AppError.Remote("remote err", "connect"),
+                    AppError.Shell("shell err", "ls", 1, ""),
+                    AppError.LocalIO("io err", "/tmp"),
+                    AppError.Restic("restic err", 1, ""),
+                    AppError.Parse("parse err"),
+                    AppError.Cancelled,
+                )
+            errors.forEach { error ->
+                val result: AppResult<Unit> = err(error)
+                result.isFailure shouldBe true
+                result.errorOrNull()?.message shouldBe error.message
+            }
+        }
+    }
+
+    context("AppResult.Failure direct") {
+        test("holds an error") {
+            val error = AppError.Network("network error")
+            val result: AppResult<String> = AppResult.Failure(error)
+            result.isSuccess shouldBe false
+            result.isFailure shouldBe true
+            result.errorOrNull() shouldBe error
+        }
+
+        test("fold calls onFailure") {
+            val result: AppResult<Int> = AppResult.Failure(AppError.Parse("parse failed"))
+            val folded =
+                result.fold(
+                    onSuccess = { 0 },
+                    onFailure = { error -> error.message.length },
+                )
+            folded shouldBe "parse failed".length
+        }
+
+        test("map passes through failure") {
+            val error = AppError.Parse("no data")
+            val result: AppResult<Int> = AppResult.Failure(error)
+            val mapped = result.map { it + 1 }
+            mapped shouldBe AppResult.Failure(error)
+        }
+
+        test("mapError transforms error") {
+            val result: AppResult<Int> = AppResult.Failure(AppError.Parse("old error"))
+            val mapped = result.mapError { AppError.Remote("mapped: ${it.message}", "transform") }
+            mapped.errorOrNull()?.message shouldBe "mapped: old error"
+        }
+    }
+
+    context("AppResult exhaustive when") {
+        test("can pattern match with is AppResult.Success") {
+            val result: AppResult<String> = AppResult.Success("data")
+            val output =
+                when (result) {
+                    is AppResult.Success -> "got: ${result.data}"
+                    is AppResult.Failure -> "err: ${result.error.message}"
+                }
+            output shouldBe "got: data"
+        }
+
+        test("can pattern match with is AppResult.Failure") {
+            val result: AppResult<String> = AppResult.Failure(AppError.Cancelled)
+            val output =
+                when (result) {
+                    is AppResult.Success -> "got: ${result.data}"
+                    is AppResult.Failure -> "err: ${result.error.message}"
+                }
+            output shouldBe "err: 操作被取消"
+        }
+    }
+
+    context("AppResult type inference") {
+        test("AppResult.Success with Unit") {
+            val result: AppResult<Unit> = AppResult.Success(Unit)
+            result.isSuccess shouldBe true
+            result.getOrDefault(Unit) shouldBe Unit
+        }
+
+        test("AppResult.Failure with Nothing") {
+            val result: AppResult<Int> = AppResult.Failure(AppError.Cancelled)
+            result.isFailure shouldBe true
+        }
+    }
+
+    context("err function short-form") {
+        test("err() returns AppResult.Failure") {
+            val result: AppResult<String> = err(AppError.Remote("upload failed", "upload"))
+            result.shouldBeInstanceOf<AppResult.Failure>()
+            (result as AppResult.Failure).error shouldBe AppError.Remote("upload failed", "upload")
+        }
+    }
+})

app/src/test/java/com/example/androidbackupgui/backup/ResticBinaryTest.kt

@@ -0,0 +1,13 @@
+package com.example.androidbackupgui.backup
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+
+class ResticBinaryTest : FunSpec({
+
+    context("ResticBinary") {
+        test("isReady returns false before prepare is called") {
+            ResticBinary.isReady() shouldBe false
+        }
+    }
+})

app/src/test/java/com/example/androidbackupgui/backup/ResticCommandRunnerTest.kt

@@ -0,0 +1,110 @@
+package com.example.androidbackupgui.backup
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.shouldBe
+import io.kotest.property.Arb
+import io.kotest.property.arbitrary.int
+import io.kotest.property.arbitrary.list
+import io.kotest.property.arbitrary.string
+import io.kotest.property.checkAll
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+class ResticCommandRunnerTest : FunSpec({
+
+    val defaultRunner = ResticCommandRunner()
+
+    context("buildCommandArgs") {
+        test("prepends default binary path") {
+            val args = defaultRunner.buildCommandArgs(listOf("init", "--json"))
+            args shouldBe listOf("restic", "init", "--json")
+        }
+
+        test("uses custom binary path") {
+            val runner = ResticCommandRunner()
+            runner.binaryPath = "/data/data/com.termux/files/usr/bin/restic"
+            val args = runner.buildCommandArgs(listOf("backup", "/sdcard"))
+            args shouldBe
+                listOf(
+                    "/data/data/com.termux/files/usr/bin/restic",
+                    "backup",
+                    "/sdcard",
+                )
+        }
+
+        test("returns empty args list when called with empty list") {
+            val args = defaultRunner.buildCommandArgs(emptyList())
+            args shouldBe listOf("restic")
+        }
+
+        test("preserves argument order") {
+            val runner = ResticCommandRunner()
+            runner.binaryPath = "restic"
+            val args = runner.buildCommandArgs(listOf("a", "b", "c"))
+            args shouldBe listOf("restic", "a", "b", "c")
+        }
+
+        test("property: any list of string args mainatains length") {
+            checkAll(Arb.list(Arb.string(1..20), 0..10)) { inputArgs ->
+                val args = defaultRunner.buildCommandArgs(inputArgs)
+                args shouldHaveSize (inputArgs.size + 1)
+                args[0] shouldBe "restic"
+            }
+        }
+    }
+
+    context("runRestic(vararg)") {
+        test("delegates to runRestic(List) and returns failure on nonexistent binary") {
+            val runner = ResticCommandRunner()
+            runner.binaryPath = "/nonexistent/restic"
+            val result = runner.runRestic(mapOf("RESTIC_REPOSITORY" to "/tmp/repo"), "version")
+            result.exitCode shouldBe -1
+            result.stdout shouldBe ""
+        }
+    }
+
+    context("CommandResult serialization") {
+        test("serializes and deserializes correctly") {
+            val original =
+                ResticCommandRunner.CommandResult(
+                    stdout = "some output",
+                    stderr = "",
+                    exitCode = 0,
+                )
+            val json = Json.encodeToString(original)
+            val decoded = Json.decodeFromString<ResticCommandRunner.CommandResult>(json)
+            decoded.stdout shouldBe "some output"
+            decoded.stderr shouldBe ""
+            decoded.exitCode shouldBe 0
+        }
+
+        test("roundtrip property: preserves exit code") {
+            checkAll(Arb.int()) { code ->
+                val original =
+                    ResticCommandRunner.CommandResult(
+                        stdout = "out",
+                        stderr = code.toString(),
+                        exitCode = code,
+                    )
+                val json = Json.encodeToString(original)
+                val decoded = Json.decodeFromString<ResticCommandRunner.CommandResult>(json)
+                decoded.exitCode shouldBe code
+                decoded.stderr shouldBe code.toString()
+            }
+        }
+    }
+
+    context("ResticCommandRunner instantiation") {
+        test("default binary path is restic") {
+            defaultRunner.binaryPath shouldBe "restic"
+        }
+
+        test("can set custom binary path") {
+            val runner = ResticCommandRunner()
+            runner.binaryPath = "/custom/path/restic"
+            runner.binaryPath shouldBe "/custom/path/restic"
+        }
+    }
+})

ktlint.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Kotlin LSP client for code diagnostics. Collects all LSP messages."""
+import subprocess, json, sys, os, signal, time
+from pathlib import Path
+
+def run_diagnostics(project_dir: str, file_path: str, timeout: int = 60):
+    proc = subprocess.Popen(
+        ['/usr/local/bin/kotlin-language-server'],
+        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        cwd=project_dir, preexec_fn=lambda: signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+    )
+
+    def send(msg):
+        data = json.dumps(msg).encode('utf-8')
+        proc.stdin.write(f'Content-Length: {len(data)}\r\n\r\n'.encode('utf-8'))
+        proc.stdin.write(data)
+        proc.stdin.flush()
+
+    def recv(timeout_s=5):
+        content_length = 0
+        end = time.time() + timeout_s
+        while time.time() < end:
+            if proc.poll() is not None:
+                return None
+            ready = proc.stdout.readable()
+            if not ready:
+                time.sleep(0.05)
+                continue
+            line = proc.stdout.readline()
+            if not line:
+                time.sleep(0.05)
+                continue
+            line = line.decode('utf-8', errors='replace').strip()
+            if line.startswith('Content-Length:'):
+                content_length = int(line.split(':')[1].strip())
+            elif line == '' and content_length > 0:
+                body = proc.stdout.read(content_length).decode('utf-8', errors='replace')
+                return json.loads(body)
+        return 'TIMEOUT'
+
+    all_msgs = []
+    
+    send({
+        'jsonrpc': '2.0', 'id': 1, 'method': 'initialize',
+        'params': {
+            'processId': os.getpid(),
+            'capabilities': {
+                'textDocument': {'diagnostics': {'dynamicRegistration': False}},
+                'workspace': {'didChangeWatchedFiles': {'dynamicRegistration': False}}
+            },
+            'rootUri': f'file://{project_dir}',
+            'workspaceFolders': [{'uri': f'file://{project_dir}', 'name': Path(project_dir).name}]
+        }
+    })
+
+    # Read all messages until we get initialize result
+    end = time.time() + timeout
+    init_ok = False
+    while time.time() < end and not init_ok:
+        msg = recv(5)
+        if msg is None:
+            break
+        if msg == 'TIMEOUT':
+            continue
+        all_msgs.append(('init', msg))
+        if msg.get('id') == 1 and 'result' in msg:
+            init_ok = True
+
+    if not init_ok:
+        return all_msgs, f'INIT_TIMEOUT after {timeout}s'
+
+    send({'jsonrpc': '2.0', 'method': 'initialized', 'params': {}})
+
+    # Open file
+    file_uri = f'file://{file_path}'
+    with open(file_path) as f:
+        content = f.read()
+    
+    send({
+        'jsonrpc': '2.0', 'method': 'textDocument/didOpen',
+        'params': {
+            'textDocument': {
+                'uri': file_uri, 'languageId': 'kotlin',
+                'version': 1, 'text': content
+            }
+        }
+    })
+
+    # Collect messages for remaining time
+    end = time.time() + 30
+    while time.time() < end:
+        msg = recv(3)
+        if msg is None or msg == 'TIMEOUT':
+            continue
+        all_msgs.append(('open', msg))
+
+    # Shutdown
+    send({'jsonrpc': '2.0', 'id': 2, 'method': 'shutdown', 'params': {}})
+    
+    try:
+        proc.terminate()
+        proc.wait(timeout=3)
+    except:
+        proc.kill()
+    
+    return all_msgs, 'OK'
+
+if __name__ == '__main__':
+    file_path = os.path.abspath(sys.argv[1])
+    project_dir = os.path.abspath(sys.argv[2]) if len(sys.argv) > 2 else os.getcwd()
+    print(f'Project: {project_dir}')
+    print(f'File:    {file_path}\n')
+
+    msgs, status = run_diagnostics(project_dir, file_path)
+    
+    print(f'Status: {status}')
+    print(f'Messages received: {len(msgs)}\n')
+    
+    diag_count = 0
+    for phase, msg in msgs:
+        method = msg.get('method', '?')
+        if 'id' in msg:
+            method = f'response(id={msg["id"]})'
+        if 'error' in msg:
+            print(f'  [{phase}] {method} ERROR: {msg["error"]}')
+        elif method == 'window/logMessage':
+            print(f'  [{phase}] log: {msg.get("params",{}).get("message","")}')
+        elif method == 'window/showMessage':
+            print(f'  [{phase}] show: {msg.get("params",{}).get("message","")}')
+        elif method == 'textDocument/publishDiagnostics':
+            diags = msg.get('params', {}).get('diagnostics', [])
+            diag_count += len(diags)
+            uri = msg.get('params', {}).get('uri', '')
+            print(f'  [{phase}] publishDiagnostics ({len(diags)} items): {os.path.basename(uri)}')
+            for d in diags:
+                r = d.get('range', {})
+                s = r.get('start', {})
+                sev = {1:'E',2:'W',3:'I',4:'H'}.get(d.get('severity'),'?')
+                print(f'     {sev} {s.get("line",0)+1}:{s.get("character",0)+1} {d.get("message","")}')
+        elif method.startswith('response'):
+            if 'result' in msg:
+                caps = msg.get('result', {}).get('capabilities', {})
+                print(f'  [{phase}] {method} capabilities: {json.dumps(caps, indent=2)[:400]}')
+            else:
+                print(f'  [{phase}] {method}')
+        else:
+            print(f'  [{phase}] {method}: {json.dumps(msg, indent=2)[:200]}')
+    
+    print(f'\nTotal diagnostics: {diag_count}')