feat: implement rpc architecture

Author: imba97

packages/core/src/bridge/handlers/command-handlers.ts

@@ -2,6 +2,7 @@ import type { NodeHeartbeatPayload, NodeRegisterPayload } from '@frp-bridge/type
 import type { NodeManager } from '../../node'
 import type { FrpProcessManager } from '../../process'
 import type { RpcServer } from '../../rpc'
+import type { NodeDeletePayload, TunnelAddPayload, TunnelDeletePayload } from '../../rpc/message-types'
 import type { CommandHandler, CommandHandlerContext, CommandResult, RuntimeEvent } from '../../runtime'
 import type { ConfigApplyPayload, ConfigApplyRawPayload, ProxyAddPayload, ProxyRemovePayload, ProxyUpdatePayload } from '../types'
 import type { Validator } from './decorators'
@@ -470,8 +471,153 @@ export function createCommandHandlers(deps: CommandDependencies): Record<string,
     'node.register': createNodeRegisterCommand(deps) as CommandHandler,
     'node.heartbeat': createNodeHeartbeatCommand(deps) as CommandHandler,
     'node.unregister': createNodeUnregisterCommand(deps) as CommandHandler,
+    'node.delete': createNodeDeleteCommand(deps) as CommandHandler,
     'proxy.add': createProxyAddCommand(deps) as CommandHandler,
     'proxy.update': createProxyUpdateCommand(deps) as CommandHandler,
-    'proxy.remove': createProxyRemoveCommand(deps) as CommandHandler
+    'proxy.remove': createProxyRemoveCommand(deps) as CommandHandler,
+    // Tunnel commands (aliases for proxy commands, matching document spec)
+    'tunnel.add': createTunnelAddCommand(deps) as CommandHandler,
+    'tunnel.delete': createTunnelDeleteCommand(deps) as CommandHandler
   }
 }
+
+// ============================================================================
+// Tunnel Commands (matching document spec)
+// ============================================================================
+
+/**
+ * Validate tunnel add payload
+ */
+const validateTunnelAdd: Validator<TunnelAddPayload> = (payload) => {
+  if (!payload) {
+    return { valid: false, error: 'tunnel.add requires payload' }
+  }
+  if (!payload.name || typeof payload.name !== 'string') {
+    return { valid: false, error: 'tunnel.add requires payload.name' }
+  }
+  if (!payload.type || typeof payload.type !== 'string') {
+    return { valid: false, error: 'tunnel.add requires payload.type' }
+  }
+  if (typeof payload.localPort !== 'number') {
+    return { valid: false, error: 'tunnel.add requires payload.localPort to be a number' }
+  }
+  return { valid: true }
+}
+
+/**
+ * Validate tunnel delete payload
+ */
+const validateTunnelDelete: Validator<TunnelDeletePayload> = (payload) => {
+  if (!payload?.name) {
+    return { valid: false, error: 'tunnel.delete requires payload.name' }
+  }
+  return { valid: true }
+}
+
+/**
+ * Validate node delete payload
+ */
+const validateNodeDelete: Validator<NodeDeletePayload> = (payload) => {
+  if (!payload?.name) {
+    return { valid: false, error: 'node.delete requires payload.name' }
+  }
+  return { valid: true }
+}
+
+/**
+ * Local tunnel add handler (client mode)
+ * Compatible with document spec: { name, type, localPort, remotePort?, ... }
+ */
+async function tunnelAddLocal(payload: TunnelAddPayload, deps: CommandDependencies): Promise<CommandResult> {
+  // Convert TunnelAddPayload to ProxyConfig format
+  const proxyConfig = {
+    name: payload.name,
+    type: payload.type,
+    localIP: '127.0.0.1',
+    localPort: payload.localPort,
+    ...(payload.remotePort && { remotePort: payload.remotePort }),
+    ...(payload.customDomains && { customDomains: payload.customDomains }),
+    ...(payload.subdomain && { subdomain: payload.subdomain })
+  }
+
+  deps.process.addTunnel(proxyConfig)
+  return {
+    status: 'success',
+    result: { ...proxyConfig, success: true }
+  }
+}
+
+/**
+ * Create tunnel add command handler (matching document spec)
+ * This is an alias for proxy.add with different payload format
+ */
+export function createTunnelAddCommand(deps: CommandDependencies): CommandHandler<TunnelAddPayload> {
+  return compose<TunnelAddPayload>(
+    withErrorHandling,
+    withValidation(validateTunnelAdd),
+    withPortConflictCheck
+  )(
+    withModeRouting(
+      tunnelAddLocal,
+      'tunnel.add',
+      payload => ({ proxy: payload as any })
+    )(async () => ({ status: 'success' }), deps),
+    deps
+  )
+}
+
+/**
+ * Local tunnel delete handler (client mode)
+ */
+async function tunnelDeleteLocal(payload: TunnelDeletePayload, deps: CommandDependencies): Promise<CommandResult> {
+  deps.process.removeTunnel(payload.name)
+  return {
+    status: 'success',
+    result: { name: payload.name, success: true }
+  }
+}
+
+/**
+ * Create tunnel delete command handler (matching document spec)
+ * This is an alias for proxy.remove
+ */
+export function createTunnelDeleteCommand(deps: CommandDependencies): CommandHandler<TunnelDeletePayload> {
+  return compose<TunnelDeletePayload>(
+    withErrorHandling,
+    withValidation(validateTunnelDelete)
+  )(
+    withModeRouting(
+      tunnelDeleteLocal,
+      'tunnel.delete',
+      payload => ({ name: payload.name })
+    )(async () => ({ status: 'success' }), deps),
+    deps
+  )
+}
+
+/**
+ * Node delete handler (server mode only)
+ * Removes a node from the node manager
+ */
+function nodeDeleteCore(deps: CommandDependencies): CommandHandler<NodeDeletePayload> {
+  return async (command) => {
+    const nodeName = command.payload!.name
+    deps.nodeManager!.unregisterNode(nodeName)
+    return {
+      status: 'success',
+      result: { deletedNode: nodeName, success: true }
+    }
+  }
+}
+
+/**
+ * Create node delete command handler (matching document spec)
+ */
+export function createNodeDeleteCommand(deps: CommandDependencies): CommandHandler<NodeDeletePayload> {
+  return compose<NodeDeletePayload>(
+    withErrorHandling,
+    withNodeManager,
+    withServerModeOnly,
+    withValidation(validateNodeDelete)
+  )(nodeDeleteCore(deps), deps)
+}

packages/core/src/rpc/index.ts

@@ -2,4 +2,4 @@ export * from './message-types'
 export * from './middleware'
 export * from './reconnect-strategy'
 export { RpcClient, type RpcClientOptions } from './rpc-client'
-export { RpcServer, type RpcServerOptions } from './rpc-server'
+export { type RpcCommandStatus, RpcServer, type RpcServerOptions } from './rpc-server'

packages/core/src/rpc/message-types.ts

@@ -69,6 +69,87 @@ export interface PongMessage {
  */
 export type RpcMessage = RegisterMessage | RpcRequest | RpcResponse | PingMessage | PongMessage
 
+// ============================================================================
+// Event-based Message Types (compatible with architecture document)
+// ============================================================================
+
+/**
+ * Event-based RPC message type (matching document spec)
+ */
+export interface EventRpcMessage {
+  type: 'command' | 'event'
+  action: string
+  payload: unknown
+  id?: string
+  targetNodeId?: string
+}
+
+/**
+ * Command message (frps -> frpc)
+ */
+export interface CommandRpcMessage extends EventRpcMessage {
+  type: 'command'
+  id: string
+}
+
+/**
+ * Event message (frpc -> frps)
+ */
+export interface EventRpcMessageEvent extends EventRpcMessage {
+  type: 'event'
+  id?: string
+}
+
+/**
+ * Tunnel add payload
+ */
+export interface TunnelAddPayload {
+  name: string
+  type: 'tcp' | 'http' | 'https' | 'stcp' | 'sudp' | 'xtcp'
+  localPort: number
+  remotePort?: number
+  customDomains?: string[]
+  subdomain?: string
+  [key: string]: unknown
+}
+
+/**
+ * Tunnel delete payload
+ */
+export interface TunnelDeletePayload {
+  name: string
+}
+
+/**
+ * Tunnel response payload
+ */
+export interface TunnelResponsePayload {
+  success: boolean
+  error?: string
+  tunnel?: TunnelAddPayload
+}
+
+/**
+ * Node delete payload
+ */
+export interface NodeDeletePayload {
+  name: string
+}
+
+/**
+ * Node response payload
+ */
+export interface NodeResponsePayload {
+  success: boolean
+  error?: string
+  deletedNode?: string
+}
+
+/**
+ * All message types including event-based
+ */
+export type AllRpcMessage = RpcMessage | EventRpcMessage
+
 /**
  * 类型守卫：检查是否为注册消息
  */
@@ -109,3 +190,64 @@ export function isPongMessage(msg: unknown): msg is PongMessage {
   return typeof msg === 'object' && msg !== null
     && (msg as any).type === RpcMessageType.PONG
 }
+
+// ============================================================================
+// Event-based Message Type Guards
+// ============================================================================
+
+/**
+ * 类型守卫：检查是否为 Event-based RPC 消息
+ */
+export function isEventRpcMessage(msg: unknown): msg is EventRpcMessage {
+  return typeof msg === 'object' && msg !== null
+    && ((msg as any).type === 'command' || (msg as any).type === 'event')
+    && typeof (msg as any).action === 'string'
+    && 'payload' in (msg as any)
+}
+
+/**
+ * 类型守卫：检查是否为 Command 消息
+ */
+export function isCommandMessage(msg: unknown): msg is CommandRpcMessage {
+  return isEventRpcMessage(msg)
+    && (msg as any).type === 'command'
+    && typeof (msg as any).id === 'string'
+}
+
+/**
+ * 类型守卫：检查是否为 Event 消息
+ */
+export function isEventMessage(msg: unknown): msg is EventRpcMessageEvent {
+  return isEventRpcMessage(msg)
+    && (msg as any).type === 'event'
+}
+
+/**
+ * 类型守卫：检查是否为 TunnelAddPayload
+ */
+export function isTunnelAddPayload(data: unknown): data is TunnelAddPayload {
+  if (typeof data !== 'object' || data === null)
+    return false
+
+  const payload = data as TunnelAddPayload
+  return typeof payload.name === 'string'
+    && typeof payload.type === 'string'
+    && typeof payload.localPort === 'number'
+    && (payload.remotePort === undefined || typeof payload.remotePort === 'number')
+}
+
+/**
+ * 类型守卫：检查是否为 TunnelDeletePayload
+ */
+export function isTunnelDeletePayload(data: unknown): data is TunnelDeletePayload {
+  return typeof data === 'object' && data !== null
+    && typeof (data as any).name === 'string'
+}
+
+/**
+ * 类型守卫：检查是否为 NodeDeletePayload
+ */
+export function isNodeDeletePayload(data: unknown): data is NodeDeletePayload {
+  return typeof data === 'object' && data !== null
+    && typeof (data as any).name === 'string'
+}