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>
This commit is contained in:
claude-code-best
2026-04-11 23:22:55 +08:00
committed by GitHub
parent 2fea429dc6
commit 09fc515edb
124 changed files with 10958 additions and 577 deletions

View File

@@ -1,11 +1,207 @@
// Auto-generated stub — replace with real implementation
import type { TaskStateBase, SetAppState } from '../../Task.js'
// Background task entry for local workflow execution.
// Makes workflow scripts visible in the footer pill and Shift+Down
// dialog. Follows the DreamTask pattern: lifecycle + UI surfacing via
// the existing task registry.
import type { AppState } from '../../state/AppState.js'
import type { SetAppState, Task, TaskStateBase } from '../../Task.js'
import { createTaskStateBase, generateTaskId } from '../../Task.js'
import type { AgentId } from '../../types/ids.js'
import { logForDebugging } from '../../utils/debug.js'
import { registerTask, updateTaskState } from '../../utils/task/framework.js'
export type LocalWorkflowTaskState = TaskStateBase & {
type: 'local_workflow'
/** meta.name from the workflow script (e.g. 'spec'). */
workflowName: string
/** Absolute path to the workflow file on disk. */
workflowFile: string
/** Human-readable one-line summary for the task list. */
summary?: string
description: string
/** Number of sub-agents spawned by this workflow. */
agentCount?: number
/** Captured output from workflow execution. */
output?: string
/** Agent that spawned this task. Used for orphan cleanup. */
agentId?: AgentId
/** Abort controller for cancellation. */
abortController?: AbortController
/**
* Pending action for a sub-agent within this workflow.
* The workflow execution loop polls this field and acts on it.
*/
pendingAgentAction?: {
kind: 'skip' | 'retry'
agentId: AgentId
requestedAt: number
}
}
export function isLocalWorkflowTask(
value: unknown,
): value is LocalWorkflowTaskState {
return (
typeof value === 'object' &&
value !== null &&
'type' in value &&
(value as { type: string }).type === 'local_workflow'
)
}
export function registerLocalWorkflowTask(
setAppState: SetAppState,
opts: {
description: string
workflowName: string
workflowFile: string
summary?: string
toolUseId?: string
agentId?: AgentId
abortController?: AbortController
},
): string {
const id = generateTaskId('local_workflow')
const task: LocalWorkflowTaskState = {
...createTaskStateBase(id, 'local_workflow', opts.description, opts.toolUseId),
type: 'local_workflow',
status: 'running',
workflowName: opts.workflowName,
workflowFile: opts.workflowFile,
summary: opts.summary,
agentId: opts.agentId,
abortController: opts.abortController,
}
registerTask(task, setAppState)
return id
}
export function completeWorkflowTask(
taskId: string,
setAppState: SetAppState,
): void {
updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => ({
...task,
status: 'completed',
endTime: Date.now(),
notified: true,
abortController: undefined,
}))
}
export function failWorkflowTask(
taskId: string,
setAppState: SetAppState,
): void {
updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => ({
...task,
status: 'failed',
endTime: Date.now(),
notified: true,
abortController: undefined,
}))
}
/**
* Kill a running workflow task. Called from BackgroundTasksDialog
* via the feature-gated `killWorkflowTask` binding.
*/
export function killWorkflowTask(
taskId: string,
setAppState: SetAppState,
): void {
updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => {
if (task.status !== 'running') return task
task.abortController?.abort()
return {
...task,
status: 'killed',
endTime: Date.now(),
notified: true,
abortController: undefined,
}
})
}
/**
* Skip the current agent step within a running workflow.
* Called from BackgroundTasksDialog via the feature-gated
* `skipWorkflowAgent` binding: skipWorkflowAgent(taskId, agentId, setAppState).
*/
export function skipWorkflowAgent(
taskId: string,
agentId: AgentId,
setAppState: SetAppState,
): void {
logForDebugging(
`skipWorkflowAgent: skipping agent ${agentId} in workflow task ${taskId}`,
)
updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => {
if (task.status !== 'running') return task
return {
...task,
pendingAgentAction: {
kind: 'skip',
agentId,
requestedAt: Date.now(),
},
}
})
}
/**
* Retry the current agent step within a running workflow.
* Called from BackgroundTasksDialog via the feature-gated
* `retryWorkflowAgent` binding: retryWorkflowAgent(taskId, agentId, setAppState).
*/
export function retryWorkflowAgent(
taskId: string,
agentId: AgentId,
setAppState: SetAppState,
): void {
logForDebugging(
`retryWorkflowAgent: retrying agent ${agentId} in workflow task ${taskId}`,
)
updateTaskState<LocalWorkflowTaskState>(taskId, setAppState, task => {
if (task.status !== 'running') return task
return {
...task,
pendingAgentAction: {
kind: 'retry',
agentId,
requestedAt: Date.now(),
},
}
})
}
/**
* Kill all running workflow tasks spawned by a given agent.
* Called from runAgent.ts finally block.
*/
export function killWorkflowTasksForAgent(
agentId: AgentId,
getAppState: () => AppState,
setAppState: SetAppState,
): void {
const tasks = getAppState().tasks ?? {}
for (const [taskId, task] of Object.entries(tasks)) {
if (
isLocalWorkflowTask(task) &&
task.agentId === agentId &&
task.status === 'running'
) {
logForDebugging(
`killWorkflowTasksForAgent: killing orphaned workflow task ${taskId} (agent ${agentId} exiting)`,
)
killWorkflowTask(taskId, setAppState)
}
}
}
export const LocalWorkflowTask: Task = {
name: 'LocalWorkflowTask',
type: 'local_workflow',
async kill(taskId: string, setAppState: SetAppState) {
killWorkflowTask(taskId, setAppState)
},
}
export const killWorkflowTask: (id: string, setAppState: SetAppState) => void = (() => {});
export const skipWorkflowAgent: (id: string, agentId: string, setAppState: SetAppState) => void = (() => {});
export const retryWorkflowAgent: (id: string, agentId: string, setAppState: SetAppState) => void = (() => {});

View File

@@ -1,10 +1,139 @@
// Auto-generated stub — replace with real implementation
import type { TaskStateBase, SetAppState } from '../../Task.js';
import type { AppState } from '../../state/AppState.js';
import type { AgentId } from '../../types/ids.js';
// Background task entry for MCP resource monitoring.
// Tracks a long-running subscription to an MCP server resource so the
// otherwise-invisible stream is visible in the footer pill and Shift+Down
// dialog. Follows the DreamTask pattern: pure UI surfacing via the existing
// task registry.
import type { AppState } from '../../state/AppState.js'
import type { SetAppState, Task, TaskStateBase } from '../../Task.js'
import { createTaskStateBase, generateTaskId } from '../../Task.js'
import type { AgentId } from '../../types/ids.js'
import { logForDebugging } from '../../utils/debug.js'
import { registerTask, updateTaskState } from '../../utils/task/framework.js'
export type MonitorMcpTaskState = TaskStateBase & {
type: 'monitor_mcp';
};
export const killMonitorMcp: (taskId: string, setAppState: SetAppState) => void = (() => {});
export const killMonitorMcpTasksForAgent: (agentId: AgentId, getAppState: () => AppState, setAppState: SetAppState) => void = (() => {});
type: 'monitor_mcp'
/** The MCP server name being monitored. */
serverName: string
/** The resource URI being subscribed to. */
resourceUri: string
/** The shell command used to drive monitoring (if any). */
command?: string
/** Agent that spawned this task. Used to kill orphaned tasks on agent exit. */
agentId?: AgentId
/** Abort controller to cancel the subscription. */
abortController?: AbortController
}
export function isMonitorMcpTask(task: unknown): task is MonitorMcpTaskState {
return (
typeof task === 'object' &&
task !== null &&
'type' in task &&
task.type === 'monitor_mcp'
)
}
export function registerMonitorMcpTask(
setAppState: SetAppState,
opts: {
description: string
serverName: string
resourceUri: string
command?: string
toolUseId?: string
agentId?: AgentId
abortController?: AbortController
},
): string {
const id = generateTaskId('monitor_mcp')
const task: MonitorMcpTaskState = {
...createTaskStateBase(id, 'monitor_mcp', opts.description, opts.toolUseId),
type: 'monitor_mcp',
status: 'running',
serverName: opts.serverName,
resourceUri: opts.resourceUri,
command: opts.command,
agentId: opts.agentId,
abortController: opts.abortController,
}
registerTask(task, setAppState)
return id
}
export function completeMonitorMcpTask(
taskId: string,
setAppState: SetAppState,
): void {
updateTaskState<MonitorMcpTaskState>(taskId, setAppState, task => ({
...task,
status: 'completed',
endTime: Date.now(),
notified: true,
abortController: undefined,
}))
}
export function failMonitorMcpTask(
taskId: string,
setAppState: SetAppState,
): void {
updateTaskState<MonitorMcpTaskState>(taskId, setAppState, task => ({
...task,
status: 'failed',
endTime: Date.now(),
notified: true,
abortController: undefined,
}))
}
export function killMonitorMcp(
taskId: string,
setAppState: SetAppState,
): void {
updateTaskState<MonitorMcpTaskState>(taskId, setAppState, task => {
if (task.status !== 'running') return task
task.abortController?.abort()
return {
...task,
status: 'killed',
endTime: Date.now(),
notified: true,
abortController: undefined,
}
})
}
/**
* Kill all running monitor_mcp tasks spawned by a given agent.
* Called from runAgent.ts finally block so subscriptions don't outlive
* the agent that started them.
*/
export function killMonitorMcpTasksForAgent(
agentId: AgentId,
getAppState: () => AppState,
setAppState: SetAppState,
): void {
const tasks = getAppState().tasks ?? {}
for (const [taskId, task] of Object.entries(tasks)) {
if (
isMonitorMcpTask(task) &&
task.agentId === agentId &&
task.status === 'running'
) {
logForDebugging(
`killMonitorMcpTasksForAgent: killing orphaned monitor task ${taskId} (agent ${agentId} exiting)`,
)
killMonitorMcp(taskId, setAppState)
}
}
}
export const MonitorMcpTask: Task = {
name: 'MonitorMcpTask',
type: 'monitor_mcp',
async kill(taskId, setAppState) {
killMonitorMcp(taskId, setAppState)
},
}