feat(monitoring): dispatch monitoring tasks to desktop via AMQP outbox

Replace SSE /desktop/events with priority AMQP dispatch for monitoring
runs, and add phase1/phase2 infrastructure so desktop workers can lease,
resume, report, skip, and cancel monitoring tasks over the existing
dispatch WebSocket.

- Add monitoring collect outbox worker and phase2 desktop task fields
- Add /desktop/monitoring/tasks/{lease,resume,result,skip,cancel} routes
- Introduce execution-devtools and network-observer on desktop runtime
- Refactor runtime-controller, LoginView, and doubao adapter for the new flow
- Add channelName column to tracking views

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

apps/desktop-client/src/main/renderer-devtools-proxy.ts

@@ -1,4 +1,5 @@
-import type { WebContents } from "electron/main";
+import { ipcMain } from "electron/main";
+import type { IpcMainEvent, WebContents } from "electron/main";
 
 interface RendererProxyRequest {
   url: string;
@@ -17,6 +18,16 @@ interface RendererProxyResponse {
 }
 
 let rendererWebContents: WebContents | null = null;
+let requestSequence = 0;
+const pendingRequests = new Map<string, {
+  resolve: (value: RendererProxyResponse) => void;
+  reject: (error: Error) => void;
+  timeout: ReturnType<typeof setTimeout>;
+}>();
+const rendererProxyRequestChannel = "desktop:renderer-devtools-proxy:request";
+const rendererProxyResponseChannel = "desktop:renderer-devtools-proxy:response";
+
+ipcMain.on(rendererProxyResponseChannel, handleRendererProxyResponse);
 
 export function registerRendererDevtoolsProxyTarget(webContents: WebContents): void {
   rendererWebContents = webContents;
@@ -28,7 +39,7 @@ export function registerRendererDevtoolsProxyTarget(webContents: WebContents): v
 }
 
 export function canUseRendererDevtoolsProxy(): boolean {
-  return Boolean(process.env.ELECTRON_RENDERER_URL && rendererWebContents && !rendererWebContents.isDestroyed());
+  return Boolean(rendererWebContents && !rendererWebContents.isDestroyed());
 }
 
 export async function rendererDevtoolsFetch(
@@ -38,37 +49,75 @@ export async function rendererDevtoolsFetch(
     throw new Error("renderer_devtools_proxy_unavailable");
   }
 
-  const script = `(async () => {
+  const requestId = `renderer-proxy-${Date.now()}-${requestSequence += 1}`;
+
+  return await new Promise<RendererProxyResponse>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      pendingRequests.delete(requestId);
+      reject(new Error("renderer_devtools_proxy_timeout"));
+    }, 30_000);
+
+    pendingRequests.set(requestId, {
+      resolve,
+      reject,
+      timeout,
+    });
+
     try {
-      const response = await fetch(${JSON.stringify(request.url)}, {
-        method: ${JSON.stringify(request.method)},
-        headers: ${JSON.stringify(request.headers ?? {})},
-        body: ${JSON.stringify(request.body ?? null)},
-      });
-      const bodyText = await response.text();
-      return JSON.stringify({
-        ok: response.ok,
-        status: response.status,
-        statusText: response.statusText,
-        headers: Object.fromEntries(response.headers.entries()),
-        bodyText,
+      rendererWebContents?.send(rendererProxyRequestChannel, {
+        requestId,
+        request,
       });
     } catch (error) {
-      return JSON.stringify({
-        ok: false,
-        status: 0,
-        statusText: "",
-        headers: {},
-        bodyText: "",
-        error: String(error && (error.message || error)),
-      });
+      clearTimeout(timeout);
+      pendingRequests.delete(requestId);
+      reject(error instanceof Error ? error : new Error("renderer_devtools_proxy_send_failed"));
     }
-  })()`;
+  });
+}
 
-  const serialized = await rendererWebContents.executeJavaScript(script, true);
-  if (typeof serialized !== "string" || !serialized) {
-    throw new Error("renderer_devtools_proxy_empty_response");
+function handleRendererProxyResponse(
+  event: IpcMainEvent,
+  payload: {
+    requestId?: unknown;
+    response?: unknown;
+  },
+): void {
+  if (rendererWebContents && event.sender !== rendererWebContents) {
+    return;
   }
 
-  return JSON.parse(serialized) as RendererProxyResponse;
+  const requestId = typeof payload?.requestId === "string" ? payload.requestId : "";
+  if (!requestId) {
+    return;
+  }
+
+  const pending = pendingRequests.get(requestId);
+  if (!pending) {
+    return;
+  }
+
+  clearTimeout(pending.timeout);
+  pendingRequests.delete(requestId);
+
+  const response = payload.response;
+  if (!isRendererProxyResponse(response)) {
+    pending.reject(new Error("renderer_devtools_proxy_invalid_response"));
+    return;
+  }
+
+  pending.resolve(response);
+}
+
+function isRendererProxyResponse(value: unknown): value is RendererProxyResponse {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+
+  const candidate = value as Partial<RendererProxyResponse>;
+  return typeof candidate.ok === "boolean"
+    && typeof candidate.status === "number"
+    && typeof candidate.statusText === "string"
+    && typeof candidate.bodyText === "string"
+    && Boolean(candidate.headers && typeof candidate.headers === "object");
 }