修复本地环境修复卡在准备状态

C4AL · C4AL · commit 2c7c4601fddf · 2026-05-12T22:56:31.000+08:00
宿主修复请求增加完整异常兜底，确保无效 action、修复执行异常、复检异常都会回传失败结果及日志路径。

修复服务将准备阶段目录创建、日志路径解析和初始状态写入纳入失败结果，并回写 completed/failed 状态。

Dashboard 在修复 Promise reject 时将对应进度卡片切到 failed，并保留现有命令输出和日志上下文。

新增和更新 .NET 与 Vitest 用例，覆盖早期准备失败、宿主结果回传、前端 reject 失败态和桥接超时错误。
diff --git a/resources/webui/upstream/source/src/pages/DashboardPage.tsx b/resources/webui/upstream/source/src/pages/DashboardPage.tsx
@@ -503,6 +503,17 @@ export function DashboardPage() {
       );
     } catch (error) {
       const message = error instanceof Error ? error.message : t('common.unknown_error');
+      setLocalRepairProgressItemId(itemId);
+      setLocalRepairProgress((current) => ({
+        actionId,
+        phase: 'failed',
+        message,
+        commandLine: current?.actionId === actionId ? current.commandLine : null,
+        recentOutput: current?.actionId === actionId ? current.recentOutput : [],
+        logPath: current?.actionId === actionId ? current.logPath : null,
+        updatedAt: new Date().toISOString(),
+        exitCode: current?.actionId === actionId ? current.exitCode : null,
+      }));
       showNotification(message, 'error');
     } finally {
       setRepairingTarget((current) =>
diff --git a/resources/webui/upstream/source/tests/desktop/localDependencyBridge.test.ts b/resources/webui/upstream/source/tests/desktop/localDependencyBridge.test.ts
@@ -207,6 +207,24 @@ describe('local dependency desktop bridge', () => {
     });
   });
 
+  it('rejects a repair request with the desktop timeout error when no result arrives', async () => {
+    vi.useFakeTimers();
+    const repairRequestIds: string[] = [];
+    const bridge = await loadBridge({
+      runRepair: (_actionId, requestId) => {
+        repairRequestIds.push(requestId);
+        return true;
+      },
+    });
+
+    const request = bridge.runLocalDependencyRepair('repair-user-path');
+    const rejected = expect(request).rejects.toThrow('桌面端响应超时');
+    expect(repairRequestIds).toHaveLength(1);
+    await vi.advanceTimersByTimeAsync(35 * 60_000);
+
+    await rejected;
+  });
+
   it('passes required environment repair action through the existing repair channel', async () => {
     const repairCalls: Array<{ actionId: string; requestId: string }> = [];
     const bridge = await loadBridge({
diff --git a/resources/webui/upstream/source/tests/pages/DashboardPage.localEnvironment.test.tsx b/resources/webui/upstream/source/tests/pages/DashboardPage.localEnvironment.test.tsx
@@ -509,6 +509,10 @@ describe('DashboardPage local environment loading', () => {
       expect(
         within(nodeNpmRow).getByRole('button', { name: 'dashboard.local_environment_repair' })
       ).not.toBeDisabled();
+      expect(
+        within(nodeNpmRow).getByText('dashboard.local_environment_repair_phase_failed')
+      ).toBeInTheDocument();
+      expect(within(nodeNpmRow).getByText('用户取消了管理员授权。')).toBeInTheDocument();
     });
   });
 
diff --git a/src/CodexCliPlus.App/MainWindow.WebViewHost.cs b/src/CodexCliPlus.App/MainWindow.WebViewHost.cs
@@ -1094,56 +1094,87 @@ private async Task RunLocalDependencyRepairAsync(string? requestId, string? acti
             string.IsNullOrWhiteSpace(actionId) || !LocalDependencyRepairActionIds.IsKnown(actionId)
         )
         {
+            var invalidActionResult = CreateLocalDependencyRepairFailure(
+                actionId ?? string.Empty,
+                "未知修复动作。",
+                "桌面端只接受内置白名单 action id。"
+            );
             PostWebUiCommand(
                 new
                 {
                     type = "localDependencyRepairResult",
                     requestId,
-                    result = new
-                    {
-                        actionId = actionId ?? string.Empty,
-                        succeeded = false,
-                        summary = "未知修复动作。",
-                        detail = "桌面端只接受内置白名单 action id。",
-                    },
+                    result = invalidActionResult,
                 }
             );
             return;
         }
 
-        PostWebUiCommand(
-            new
-            {
-                type = "localDependencyRepairStarted",
-                requestId,
-                actionId,
-            }
-        );
+        LocalDependencyRepairResult result;
+        LocalDependencySnapshot? snapshot = null;
+        try
+        {
+            PostWebUiCommand(
+                new
+                {
+                    type = "localDependencyRepairStarted",
+                    requestId,
+                    actionId,
+                }
+            );
 
-        var result = await _localDependencyRepairService.RunElevatedRepairAsync(
-            actionId,
-            progress =>
-                Dispatcher.InvokeAsync(() =>
-                    PostWebUiCommand(
-                        new
-                        {
-                            type = "localDependencyRepairProgress",
-                            requestId,
-                            progress,
-                        }
+            result = await _localDependencyRepairService.RunElevatedRepairAsync(
+                actionId,
+                progress =>
+                    Dispatcher.InvokeAsync(() =>
+                        PostWebUiCommand(
+                            new
+                            {
+                                type = "localDependencyRepairProgress",
+                                requestId,
+                                progress,
+                            }
+                        )
                     )
-                )
-        );
-        var snapshot = await _localDependencyHealthService.CheckAsync();
-        PostWebUiCommand(
-            new
+            );
+            try
             {
-                type = "localDependencyRepairResult",
-                requestId,
-                result,
-                snapshot,
+                snapshot = await _localDependencyHealthService.CheckAsync();
+            }
+            catch (Exception exception)
+            {
+                _logger.LogError("Failed to check local dependency health after repair.", exception);
+                result = CreateLocalDependencyRepairFailure(
+                    actionId,
+                    "修复后检测失败。",
+                    exception.Message,
+                    result.LogPath
+                );
             }
-        );
+
+            PostWebUiCommand(
+                new
+                {
+                    type = "localDependencyRepairResult",
+                    requestId,
+                    result,
+                    snapshot,
+                }
+            );
+        }
+        catch (Exception exception)
+        {
+            _logger.LogError($"Local dependency repair '{actionId}' failed before result.", exception);
+            result = CreateLocalDependencyRepairFailure(actionId, "本地环境修复失败。", exception.Message);
+            PostWebUiCommand(
+                new
+                {
+                    type = "localDependencyRepairResult",
+                    requestId,
+                    result,
+                }
+            );
+        }
 
         if (result.Succeeded)
         {
@@ -1156,6 +1187,40 @@ private async Task RunLocalDependencyRepairAsync(string? requestId, string? acti
         }
     }
 
+    private LocalDependencyRepairResult CreateLocalDependencyRepairFailure(
+        string actionId,
+        string summary,
+        string detail,
+        string? logPath = null
+    )
+    {
+        return new LocalDependencyRepairResult
+        {
+            ActionId = actionId,
+            Succeeded = false,
+            Summary = summary,
+            Detail = detail,
+            LogPath = string.IsNullOrWhiteSpace(logPath)
+                ? GetLocalDependencyRepairLogPath()
+                : logPath,
+        };
+    }
+
+    private string GetLocalDependencyRepairLogPath()
+    {
+        try
+        {
+            return Path.Combine(
+                _pathService.Directories.LogsDirectory,
+                "local-environment-repair.log"
+            );
+        }
+        catch
+        {
+            return "local-environment-repair.log";
+        }
+    }
+
     private static string? ReadRequestId(JsonElement root)
     {
         return
diff --git a/src/CodexCliPlus.Infrastructure/LocalEnvironment/LocalDependencyRepairService.cs b/src/CodexCliPlus.Infrastructure/LocalEnvironment/LocalDependencyRepairService.cs
@@ -120,19 +120,41 @@ public async Task<LocalDependencyRepairResult> RunElevatedRepairAsync(
             return Failure(actionId, "未知修复动作。", "前端只能调用内置白名单动作。");
         }
 
-        await _pathService.EnsureCreatedAsync(cancellationToken);
-        var statusPath = Path.Combine(
-            _pathService.Directories.RuntimeDirectory,
-            $"local-environment-repair-{Guid.NewGuid():N}.json"
-        );
-        var initialProgress = CreateProgress(
-            actionId,
-            "starting",
-            "正在准备修复。",
-            logPath: GetRepairLogPath()
-        );
-        await WriteStatusAsync(statusPath, initialProgress, cancellationToken);
-        progressReporter?.Invoke(initialProgress);
+        string? statusPath = null;
+        LocalDependencyRepairProgress? initialProgress = null;
+        try
+        {
+            statusPath = Path.Combine(
+                _pathService.Directories.RuntimeDirectory,
+                $"local-environment-repair-{Guid.NewGuid():N}.json"
+            );
+            await _pathService.EnsureCreatedAsync(cancellationToken);
+            initialProgress = CreateProgress(
+                actionId,
+                "starting",
+                "正在准备修复。",
+                logPath: GetRepairLogPath()
+            );
+            await WriteStatusAsync(statusPath, initialProgress, cancellationToken);
+            progressReporter?.Invoke(initialProgress);
+        }
+        catch (Exception exception) when (exception is not OperationCanceledException)
+        {
+            _logger.LogError($"Failed to prepare local dependency repair '{actionId}'.", exception);
+            var failure = Failure(
+                actionId,
+                "准备修复失败。",
+                exception.Message,
+                TryGetRepairLogPath()
+            );
+            if (!string.IsNullOrWhiteSpace(statusPath))
+            {
+                await TryWriteCompletedStatusAsync(statusPath, failure, cancellationToken);
+            }
+
+            TryReportProgress(progressReporter, CreateCompletedProgress(failure, initialProgress));
+            return failure;
+        }
 
         if (IsCurrentProcessRunningAsAdministrator())
         {
@@ -460,6 +482,23 @@ CancellationToken cancellationToken
         }
     }
 
+    private void TryReportProgress(
+        Action<LocalDependencyRepairProgress>? progressReporter,
+        LocalDependencyRepairProgress progress
+    )
+    {
+        try
+        {
+            progressReporter?.Invoke(progress);
+        }
+        catch (Exception exception) when (exception is not OperationCanceledException)
+        {
+            _logger.Warn(
+                $"Failed to report local dependency repair progress: {exception.Message}"
+            );
+        }
+    }
+
     private async Task TryWriteCompletedStatusAsync(
         string statusPath,
         LocalDependencyRepairResult result,
@@ -1017,8 +1056,25 @@ await AtomicFileWriter.WriteUtf8NoBomTextAsync(
 
     private string GetRepairLogPath()
     {
-        Directory.CreateDirectory(_pathService.Directories.LogsDirectory);
-        return Path.Combine(_pathService.Directories.LogsDirectory, "local-environment-repair.log");
+        var logPath = GetRepairLogPathWithoutCreatingDirectory();
+        Directory.CreateDirectory(Path.GetDirectoryName(logPath)!);
+        return logPath;
+    }
+
+    private string GetRepairLogPathWithoutCreatingDirectory() =>
+        Path.Combine(_pathService.Directories.LogsDirectory, "local-environment-repair.log");
+
+    private string? TryGetRepairLogPath()
+    {
+        try
+        {
+            return GetRepairLogPathWithoutCreatingDirectory();
+        }
+        catch (Exception exception) when (exception is not OperationCanceledException)
+        {
+            _logger.Warn($"Failed to resolve local dependency repair log path: {exception.Message}");
+            return null;
+        }
     }
 
     private static LocalDependencyRepairProgress CreateProgress(
diff --git a/tests/CodexCliPlus.Tests/AppRepairModeTests.cs b/tests/CodexCliPlus.Tests/AppRepairModeTests.cs
diff --git a/tests/CodexCliPlus.Tests/LocalEnvironment/LocalDependencyRepairServiceTests.cs b/tests/CodexCliPlus.Tests/LocalEnvironment/LocalDependencyRepairServiceTests.cs
