feat: 支持 acp-link 包进行 acp 通用的 remote-control (#292)

* fix: 修复超时问题

* feat: 添加 acp-link 代码

* refactor: 样式重构完成

* feat: RCS 添加 ACP 后端支持

- 新增 ACP WebSocket handler (agent 注册、EventBus 订阅)
- 新增 relay handler (前端 WS → acp-link 透传 + EventBus inbound 转发)
- 新增 SSE event stream 供外部消费者订阅 channel group 事件
- ACP REST 接口无鉴权 (agents、channel-groups)
- WebSocket 端点保留 token 鉴权
- SPA 路由 /acp/ 指向 acp.html

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

* feat: 添加 ACP 专属前端界面

- 新增 /acp/ SPA 页面 (agent 列表 + 实时交互)
- Agent 列表按 channel group 分组,显示在线状态
- 通过 RCS WebSocket relay 与 agent 通信
- Vite multi-page 构建 (index.html + acp.html)

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

* feat: acp-link 支持 RCS relay 双向通信

- rcs-upstream 新增 messageHandler 转发非控制消息
- server.ts 新增虚拟 WS + relay client state 处理 relay ACP 消息
- newSession/loadSession 补充 mcpServers 参数
- 连接成功后显示 ACP Dashboard URL

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

* refactor: 移除 FileExplorer 及文件操作相关代码

- 删除 FileExplorer 组件
- ACPMain 移除 Files tab,仅保留 Chat 和 History
- client.ts 移除 listDir/readFile/onFileChanges 等方法
- types.ts 移除 FileItem/FileContent/FileChange 等类型

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

* fix: 修复类型问题

* feat: RCS 后端统一 ACP/Bridge 注册逻辑

- store: EnvironmentRecord 增加 capabilities 字段、storeFindEnvironmentByMachineName 复用逻辑
- store: 新增 storeGetSessionOwners,支持未绑定 session 自动 claim
- environment: registerEnvironment 支持 ACP 复用已有记录,返回 session_id
- session: resolveOwnedWebSessionId 支持无 owner session 自动绑定
- acp-ws-handler: 新增 handleIdentify 支持 REST+WS 两步注册
- acp routes: /acp/relay 和 /acp/agents 支持 UUID 认证
- event-bus: 增加 error 类型 payload 日志

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

* feat: acp-link 改 REST 注册 + WS identify 两步流程

- rcs-upstream: 新增 registerViaRest() 通过 POST /v1/environments/bridge 注册
- rcs-upstream: WS 连接后发送 identify 替代 register,携带 agentId
- rcs-upstream: 入口链接改为 /code/?sid=${sessionId} 实现用户绑定
- server: 修复心跳跳过 relay 虚拟连接的 bug
- server: maxSessions 配置传入 RCS upstream

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

* feat: 前端统一 Chat 组件 + ACP 聊天界面重构

- 新增 chat/ 组件: ChatView, ChatInput, MessageBubble, ToolCallGroup, PermissionPanel, SessionSidebar, CommandMenu
- ACPMain: 重构支持完整 ACP 协议交互(session/prompt/permission)
- rcs-chat-adapter: 统一 bridge session SSE 适配器
- ACPClient: 增强 session 管理、permission 流程、streaming 支持
- index.css: 新增 chat 相关样式、动画、布局
- useCommands: 新增快捷命令 hook

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

* refactor: 删除 /acp/ 独立页面,ACP 聊天统一到 /code/:sessionId

- 删除 acp.html、acp-main.tsx 入口文件和 pages/acp/ 目录
- SessionDetail: ACP session 在同一页面渲染 ACPSessionDetail 组件
- App.tsx: ?sid= 参数自动调用 apiBind 绑定用户 UUID
- Dashboard: 统一 session 列表导航,ACP 显示紫色标签
- relay-client: 改用 UUID 认证替代 API token
- EnvironmentList: 显示 workerType 标签(ACP Agent / Claude Code)
- index.ts: 移除 /acp/ SPA 路由,vite.config 移除 acp 入口

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

* build: 更新构建及测试修复

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
claude-code-best
2026-04-18 17:59:29 +08:00
committed by GitHub
parent 29cc74a170
commit 34154ee3f5
142 changed files with 17847 additions and 5577 deletions

View File

@@ -0,0 +1,335 @@
import type { ChatTransport, UIMessage, UIMessageChunk } from "ai";
import { getUuid } from "../api/client";
import type { SessionEvent, EventPayload } from "../types";
// ============================================================
// SSE Event Bus — shared between SSE listener and transport
// ============================================================
type SSEEventHandler = (event: SessionEvent) => void;
class SSEEventBus {
private listeners: Set<SSEEventHandler> = new Set();
private eventSource: EventSource | null = null;
private _lastSeqNum = 0;
get lastSeqNum() {
return this._lastSeqNum;
}
/** Register a listener for SSE events */
onEvent(handler: SSEEventHandler): () => void {
this.listeners.add(handler);
return () => this.listeners.delete(handler);
}
/** Connect to the SSE stream for a session */
connect(sessionId: string): void {
this.disconnect();
const uuid = getUuid();
const url = `/web/sessions/${sessionId}/events?uuid=${encodeURIComponent(uuid)}`;
const es = new EventSource(url);
this.eventSource = es;
es.addEventListener("message", (e: MessageEvent) => {
try {
const data = JSON.parse(e.data) as SessionEvent;
if (data.seqNum !== undefined && data.seqNum <= this._lastSeqNum) return;
if (data.seqNum !== undefined) this._lastSeqNum = data.seqNum;
for (const handler of this.listeners) {
handler(data);
}
} catch {
// ignore parse errors
}
});
}
/** Disconnect the SSE stream */
disconnect(): void {
if (this.eventSource) {
this.eventSource.close();
this.eventSource = null;
}
this._lastSeqNum = 0;
}
}
// Singleton event bus
export const sseBus = new SSEEventBus();
// ============================================================
// RCS ChatTransport — bridges RCS SSE to AI SDK UIMessageChunk
// ============================================================
interface RCSTransportOptions {
sessionId: string;
onPermissionRequest?: (event: SessionEvent) => void;
onSessionStatus?: (status: string) => void;
onError?: (error: string) => void;
}
export class RCSTransport implements ChatTransport<UIMessage> {
private sessionId: string;
private onPermissionRequest?: (event: SessionEvent) => void;
private onSessionStatus?: (status: string) => void;
private onError?: (error: string) => void;
private unsub: (() => void) | null = null;
constructor(options: RCSTransportOptions) {
this.sessionId = options.sessionId;
this.onPermissionRequest = options.onPermissionRequest;
this.onSessionStatus = options.onSessionStatus;
this.onError = options.onError;
}
async sendMessages({
messages,
abortSignal,
}: Parameters<ChatTransport<UIMessage>["sendMessages"]>[0]): Promise<ReadableStream<UIMessageChunk>> {
const lastMessage = messages[messages.length - 1];
if (!lastMessage || lastMessage.role !== "user") {
// Return empty stream if no user message
return new ReadableStream({ start: (c) => c.close() });
}
// Extract text from the user message parts
const text = lastMessage.parts
.filter((p: UIMessage["parts"][number]): p is Extract<typeof p, { type: "text" }> => p.type === "text")
.map((p: { text: string }) => p.text)
.join("");
if (!text.trim()) {
return new ReadableStream({ start: (c) => c.close() });
}
// POST user message to the RCS backend
const uuid = getUuid();
const response = await fetch(
`/web/sessions/${this.sessionId}/events?uuid=${encodeURIComponent(uuid)}`,
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
type: "user",
uuid: crypto.randomUUID(),
content: text,
message: { content: text },
}),
signal: abortSignal,
},
);
if (!response.ok) {
const data = await response.json().catch(() => ({ error: { message: response.statusText } }));
throw new Error(data.error?.message || "Failed to send message");
}
// Create a ReadableStream from the SSE event bus
// Collects events until the assistant turn is complete
return new ReadableStream<UIMessageChunk>({
start: (controller) => {
let textId = `text-${Date.now()}`;
let started = false;
const ensureStarted = () => {
if (!started) {
started = true;
controller.enqueue({ type: "start", messageId: `msg-${Date.now()}` });
}
};
const handler = (event: SessionEvent) => {
const type = event.type;
const payload = event.payload || ({} as EventPayload);
// Skip bridge init noise
const serialized = JSON.stringify(event);
if (/Remote Control connecting/i.test(serialized)) return;
switch (type) {
// ---- Assistant text ----
case "assistant": {
const content =
typeof payload.content === "string"
? payload.content
: "";
if (content && content.trim()) {
ensureStarted();
controller.enqueue({ type: "text-start", id: textId });
controller.enqueue({ type: "text-delta", id: textId, delta: content });
controller.enqueue({ type: "text-end", id: textId });
}
// Check for embedded tool_use blocks
const msg = payload.message as Record<string, unknown> | undefined;
if (msg && typeof msg === "object" && Array.isArray(msg.content)) {
const toolBlocks = (msg.content as Array<Record<string, unknown>>).filter(
(b) => b.type === "tool_use",
);
for (const block of toolBlocks) {
ensureStarted();
const toolCallId = (block.id as string) || `call-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
controller.enqueue({
type: "tool-input-available",
toolCallId,
toolName: (block.name as string) || "tool",
input: block.input || {},
});
}
}
// Finish after assistant message
ensureStarted();
controller.enqueue({ type: "finish", finishReason: "stop" });
controller.close();
cleanup();
break;
}
// ---- Tool use events ----
case "tool_use": {
ensureStarted();
const toolCallId =
(payload as Record<string, unknown>).tool_call_id as string ||
`call-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
controller.enqueue({
type: "tool-input-available",
toolCallId,
toolName: (payload as Record<string, unknown>).tool_name as string || "tool",
input: (payload as Record<string, unknown>).tool_input || {},
});
break;
}
// ---- Tool result events ----
case "tool_result": {
ensureStarted();
const resultCallId =
(payload as Record<string, unknown>).tool_call_id as string ||
`call-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
const output =
typeof (payload as Record<string, unknown>).output === "string"
? (payload as Record<string, unknown>).output
: (payload as Record<string, unknown>).content || "";
controller.enqueue({
type: "tool-output-available",
toolCallId: resultCallId,
output: output as string,
});
break;
}
// ---- Permission / control requests ----
case "control_request":
case "permission_request": {
const req = payload.request as Record<string, unknown> | undefined;
if (req && req.subtype === "can_use_tool") {
// Forward to the UI layer for handling
this.onPermissionRequest?.(event);
}
// Don't close the stream — wait for the response
break;
}
// ---- Status events ----
case "status": {
const msg =
(typeof payload.message === "string" ? payload.message : "") ||
payload.content ||
"";
if (/connecting|waiting|initializing|Remote Control/i.test(msg)) return;
break;
}
// ---- Session status ----
case "session_status": {
if (typeof payload.status === "string") {
this.onSessionStatus?.(payload.status);
if (
payload.status === "archived" ||
payload.status === "inactive"
) {
ensureStarted();
controller.enqueue({ type: "finish", finishReason: "stop" });
controller.close();
cleanup();
}
}
break;
}
// ---- Errors ----
case "error": {
ensureStarted();
controller.enqueue({
type: "error",
errorText: String(payload.message || payload.content || "Unknown error"),
});
controller.enqueue({ type: "finish", finishReason: "error" });
controller.close();
cleanup();
break;
}
// ---- Interrupt ----
case "interrupt": {
ensureStarted();
controller.enqueue({ type: "abort", reason: "Session interrupted" });
controller.close();
cleanup();
break;
}
// ---- Skip noise ----
case "partial_assistant":
case "result":
case "result_success":
case "control_response":
case "permission_response":
case "system":
case "task_state":
case "automation_state":
return;
default:
return;
}
};
const cleanup = () => {
if (this.unsub) {
this.unsub();
this.unsub = null;
}
};
this.unsub = sseBus.onEvent(handler);
// Handle abort
if (abortSignal) {
const onAbort = () => {
controller.enqueue({ type: "abort", reason: "Aborted" });
controller.close();
cleanup();
abortSignal.removeEventListener("abort", onAbort);
};
abortSignal.addEventListener("abort", onAbort);
}
},
});
}
/** Not supported — RCS doesn't have stream resumption */
reconnectToStream(): Promise<ReadableStream<UIMessageChunk> | null> {
return Promise.resolve(null);
}
/** Clean up listeners */
destroy(): void {
if (this.unsub) {
this.unsub();
this.unsub = null;
}
}
}