feat: 远程群控 (#243)

* feat: restore pipe IPC, LAN pipes, monitor tool, and PR-package features

Core IPC system (UDS_INBOX):
- PipeServer/PipeClient with UDS + TCP dual transport, NDJSON protocol
- PipeRegistry: machineId-based role assignment, file locking
- Master/slave attach, prompt relay, permission forwarding
- Heartbeat lifecycle with parallel isPipeAlive probes
- Commands: /pipes, /attach, /detach, /send, /claim-main, /pipe-status

LAN Pipes (LAN_PIPES):
- UDP multicast beacon (224.0.71.67:7101) for zero-config LAN discovery
- PipeServer TCP listener, PipeClient TCP connect mode
- Heartbeat auto-attaches LAN peers via TCP
- Cross-machine attach allowed regardless of role
- /pipes shows [LAN] peers with role + hostname/IP
- SendMessageTool supports tcp: scheme with user consent

Architecture — extracted hooks from REPL.tsx (~830 lines → ~20 lines):
- usePipeIpc: lifecycle (bootstrap, handlers, heartbeat, cleanup)
- usePipeRelay: slave→master message relay via module singleton
- usePipePermissionForward: permission request/cancel forwarding
- usePipeRouter: selected pipe input routing with role+IP labels
- Shared ndjsonFramer.ts replaces 3 duplicate NDJSON parsers

Key fixes applied during development:
- Multicast binds to correct LAN interface (not WSL/Docker)
- Beacon ref stored as module singleton (not Zustand state mutation)
- Heartbeat preserves LAN peers in discoveredPipes and selectedPipes
- Disconnect handler calls removeSlaveClient (fixes listener leak)
- cleanupStaleEntries probes without lock, writes briefly under lock
- getMachineId uses async execFile (not blocking execSync)
- globalThis.__pipeSendToMaster replaced with setPipeRelay singleton
- M key only toggles route mode when selector panel is expanded
- User prompt displayed in message list on pipe broadcast
- Broadcast notifications show [role] + hostname/IP for LAN peers

Other restored features:
- Monitor tool: /monitor command, MonitorTool, MonitorMcpTask lifecycle
- Daemon supervisor and remoteControlServer command
- Tools: SnipTool, SleepTool, ListPeersTool, SendUserFileTool,
  WebBrowserTool, WorkflowTool, and 10+ stub→implementation rewrites
- Feature flags: UDS_INBOX, LAN_PIPES, MONITOR_TOOL, FORK_SUBAGENT,
  KAIROS, COORDINATOR_MODE, WORKFLOW_SCRIPTS, HISTORY_SNIP

Tests: 2190 pass / 0 fail (15 new: lanBeacon 7, peerAddress 8)

* fix: resolve merge conflicts and fix all tsc/test errors after main merge

- Export ToolResultBlockParam from Tool.ts (14 tool files fixed)
- Migrate ink imports from ../../ink.js to @anthropic/ink (7 files)
- Fix toolUseID → toolUseId typo in monitor.ts and MonitorTool.tsx
- Add fallback values for string|undefined type errors (8 locations)
- Fix AppState type in assistant.ts, add NewInstallWizard stubs
- Fix ParsedRepository.repo → .name in subscribe-pr.ts
- Fix AgentId/string type mismatch in BackgroundTasksDialog.tsx
- Fix PipeRelayFn return type in pipePermissionRelay.ts
- Use PipeMessage type in usePipeRelay.ts
- Fix lanBeacon.test.ts mock type assertions
- Create missing MouseActionEvent class for ink package
- Use ansi: color format instead of bare "green"/"red"
- Resolve theme.permission access via getTheme()

Result: 0 tsc errors, 2496 tests pass, 0 fail

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: 恢复 /poor 的说明

---------

Co-authored-by: unraid <local@unraid.local>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

src/hooks/usePipePermissionForward.ts

@@ -0,0 +1,195 @@
+/**
+ * usePipePermissionForward — Forward slave permission requests to master UI.
+ *
+ * Subscribes to slave pipe messages via subscribePipeEntries, and:
+ * 1. permission_request → enqueue into toolUseConfirmQueue for master approval
+ * 2. permission_cancel → remove from queue
+ * 3. stream/error/done → display as system messages
+ */
+import { feature } from 'bun:bundle'
+import { useEffect } from 'react'
+import type { Tool, ToolUseContext } from '../Tool.js'
+import type { MessageType } from '../types/message.js'
+
+type Deps = {
+  store: { getState: () => any }
+  tools: Tool<any, any>[]
+  setMessages: (action: React.SetStateAction<MessageType[]>) => void
+  setToolUseConfirmQueue: (action: React.SetStateAction<any[]>) => void
+  getToolUseContext: (...args: any[]) => ToolUseContext
+  mainLoopModel: string
+}
+
+export function usePipePermissionForward({
+  store,
+  tools,
+  setMessages,
+  setToolUseConfirmQueue,
+  getToolUseContext,
+  mainLoopModel,
+}: Deps): void {
+  useEffect(() => {
+    if (!feature('UDS_INBOX')) return
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { subscribePipeEntries, getSlaveClient } =
+      require('./useMasterMonitor.js') as typeof import('./useMasterMonitor.js')
+    const { getPipeIpc } =
+      require('../utils/pipeTransport.js') as typeof import('../utils/pipeTransport.js')
+    const { createAssistantMessage, createSystemMessage } =
+      require('../utils/messages.js') as typeof import('../utils/messages.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+
+    return subscribePipeEntries(
+      (pipeName: string, entry: { type: string; content: string }) => {
+        const content = entry.content.trim()
+        const pipeIpcState = getPipeIpc(store.getState())
+        const peerInfo = (pipeIpcState.discoveredPipes ?? []).find(
+          (pipe: { pipeName: string }) => pipe.pipeName === pipeName,
+        )
+        const isLan = peerInfo?.ip && peerInfo.ip !== pipeIpcState.localIp
+        const displayRole = peerInfo
+          ? isLan
+            ? `${peerInfo.role} ${peerInfo.hostname}/${peerInfo.ip}`
+            : peerInfo.role
+          : pipeName
+
+        if (entry.type === 'permission_request') {
+          try {
+            const payload = JSON.parse(content)
+            const tool = tools.find(
+              candidate => candidate.name === payload.toolName,
+            )
+            const client = getSlaveClient(pipeName)
+            if (!client) return
+
+            if (!tool) {
+              client.send({
+                type: 'permission_response',
+                data: JSON.stringify({
+                  requestId: payload.requestId,
+                  behavior: 'deny',
+                  feedback: `Tool "${payload.toolName}" is not available in main.`,
+                }),
+              })
+              return
+            }
+
+            const assistantMessage = createAssistantMessage({ content: '' })
+            const toolUseContext = getToolUseContext(
+              [],
+              [],
+              new AbortController(),
+              mainLoopModel,
+            )
+            setToolUseConfirmQueue((queue: any[]) => [
+              ...queue,
+              {
+                assistantMessage,
+                tool,
+                description: payload.description,
+                input: payload.input,
+                toolUseContext,
+                toolUseID: `pipe:${payload.requestId}`,
+                permissionResult: payload.permissionResult,
+                permissionPromptStartTimeMs:
+                  payload.permissionPromptStartTimeMs,
+                workerBadge: {
+                  name: `${displayRole} / ${pipeName}`,
+                  color: 'cyan',
+                },
+                onUserInteraction() {},
+                onAbort() {
+                  client.send({
+                    type: 'permission_response',
+                    data: JSON.stringify({
+                      requestId: payload.requestId,
+                      behavior: 'deny',
+                      feedback: 'Permission request was aborted in main.',
+                    }),
+                  })
+                },
+                onAllow(
+                  updatedInput: any,
+                  permissionUpdates: any,
+                  feedback: any,
+                  contentBlocks: any,
+                ) {
+                  client.send({
+                    type: 'permission_response',
+                    data: JSON.stringify({
+                      requestId: payload.requestId,
+                      behavior: 'allow',
+                      updatedInput,
+                      permissionUpdates,
+                      feedback,
+                      contentBlocks,
+                    }),
+                  })
+                },
+                onReject(feedback: any, contentBlocks: any) {
+                  client.send({
+                    type: 'permission_response',
+                    data: JSON.stringify({
+                      requestId: payload.requestId,
+                      behavior: 'deny',
+                      feedback,
+                      contentBlocks,
+                    }),
+                  })
+                },
+                async recheckPermission() {},
+              },
+            ])
+          } catch {
+            // Malformed permission request — ignore
+          }
+          return
+        }
+
+        if (entry.type === 'permission_cancel') {
+          try {
+            const payload = JSON.parse(content)
+            setToolUseConfirmQueue((queue: any[]) =>
+              queue.filter(
+                (item: any) => item.toolUseID !== `pipe:${payload.requestId}`,
+              ),
+            )
+          } catch {
+            // Malformed — ignore
+          }
+          return
+        }
+
+        let message: any = null
+
+        if (entry.type === 'stream' && content) {
+          message = createSystemMessage(
+            `[${displayRole} / ${pipeName}] ${content}`,
+            'warning',
+          )
+        } else if (entry.type === 'error') {
+          message = createSystemMessage(
+            `[${displayRole} / ${pipeName}] Error: ${content || 'no output'}`,
+            'error',
+          )
+        } else if (entry.type === 'done') {
+          message = createSystemMessage(
+            `[${displayRole} / ${pipeName}] Completed`,
+            'warning',
+          )
+        }
+
+        if (message) {
+          setMessages((prev: MessageType[]) => [...prev, message])
+        }
+      },
+    )
+  }, [
+    getToolUseContext,
+    mainLoopModel,
+    setMessages,
+    setToolUseConfirmQueue,
+    store,
+    tools,
+  ])
+}