@frp-bridge/core 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -1,177 +1,719 @@
-import { NodeRegisterPayload, NodeHeartbeatPayload, NodeInfo as NodeInfo$1, NodeListQuery, NodeListResponse, NodeStatistics, TunnelSyncPayload, ProxyConfig, ClientConfig, ServerConfig, RpcRequest } from '@frp-bridge/types';
-import { EventEmitter } from 'node:events';
+import { EventEmitter } from "node:events";
 
+//#region src/runtime/contracts.d.ts
 type Awaitable<T> = T | Promise<T>;
 type RuntimeMode = 'client' | 'server';
 type RuntimeStatus = 'idle' | 'starting' | 'running' | 'stopping' | 'error';
 interface RuntimeContext {
-    id: string;
-    mode: RuntimeMode;
-    workDir: string;
-    platform: string;
-    clock?: () => number;
-    logger?: RuntimeLogger;
+  id: string;
+  mode: RuntimeMode;
+  workDir: string;
+  platform: string;
+  clock?: () => number;
 }
 interface RuntimeLogger {
-    debug: (message: string, context?: Record<string, unknown>) => void;
-    info: (message: string, context?: Record<string, unknown>) => void;
-    warn: (message: string, context?: Record<string, unknown>) => void;
-    error: (message: string, context?: Record<string, unknown>) => void;
+  debug: (message: string, context?: Record<string, unknown>) => void;
+  info: (message: string, context?: Record<string, unknown>) => void;
+  warn: (message: string, context?: Record<string, unknown>) => void;
+  error: (message: string, context?: Record<string, unknown>) => void;
 }
 interface RuntimeState {
-    status: RuntimeStatus;
-    version: number;
-    lastAppliedAt?: number;
-    lastError?: RuntimeError;
+  status: RuntimeStatus;
+  version: number;
+  lastAppliedAt?: number;
+  lastError?: RuntimeError;
 }
 interface CommandMetadata {
-    requestId?: string;
-    correlationId?: string;
-    author?: string;
-    issuedAt?: number;
+  requestId?: string;
+  correlationId?: string;
+  author?: string;
+  issuedAt?: number;
 }
 interface RuntimeCommand<TPayload = unknown> {
-    name: string;
-    payload: TPayload;
-    metadata?: CommandMetadata;
+  name: string;
+  payload: TPayload;
+  metadata?: CommandMetadata;
 }
 interface CommandResult<TResult = unknown> {
-    status: CommandStatus;
-    version?: number;
-    events?: RuntimeEvent[];
-    result?: TResult;
-    error?: RuntimeError;
-    snapshot?: ConfigSnapshot;
+  status: CommandStatus;
+  version?: number;
+  events?: RuntimeEvent[];
+  result?: TResult;
+  error?: RuntimeError;
+  snapshot?: ConfigSnapshot;
 }
 type CommandStatus = 'success' | 'failed' | 'pending';
 interface RuntimeQuery<TPayload = unknown> {
-    name: string;
-    payload?: TPayload;
+  name: string;
+  payload?: TPayload;
 }
 interface QueryResult<TResult = unknown> {
-    result: TResult;
-    version: number;
+  result: TResult;
+  version: number;
 }
 interface RuntimeEvent<TPayload = unknown> {
-    type: string;
-    timestamp: number;
-    version?: number;
-    payload?: TPayload;
+  type: string;
+  timestamp: number;
+  version?: number;
+  payload?: TPayload;
 }
 interface RuntimeError {
-    code: RuntimeErrorCode;
-    message: string;
-    details?: Record<string, unknown>;
+  code: RuntimeErrorCode;
+  message: string;
+  details?: Record<string, unknown>;
 }
-type RuntimeErrorCode = 'VALIDATION_ERROR' | 'RUNTIME_ERROR' | 'SYSTEM_ERROR' | 'PORT_CONFLICT' | 'RPC_NOT_AVAILABLE' | 'RPC_ERROR';
+type RuntimeErrorCode = 'VALIDATION_ERROR' | 'RUNTIME_ERROR' | 'SYSTEM_ERROR' | 'PORT_CONFLICT' | 'RPC_NOT_AVAILABLE' | 'RPC_ERROR' | 'MODE_ERROR' | 'UNKNOWN_ERROR';
 interface ConfigSnapshot {
-    version: number;
-    checksum: string;
-    appliedAt: number;
-    author?: string;
-    summary?: string;
+  version: number;
+  checksum: string;
+  appliedAt: number;
+  author?: string;
+  summary?: string;
 }
 interface SnapshotStorage {
-    save: (snapshot: ConfigSnapshot) => Awaitable<void>;
-    load: (version: number) => Awaitable<ConfigSnapshot | undefined>;
-    list: () => Awaitable<ConfigSnapshot[]>;
+  save: (snapshot: ConfigSnapshot) => Awaitable<void>;
+  load: (version: number) => Awaitable<ConfigSnapshot | undefined>;
+  list: () => Awaitable<ConfigSnapshot[]>;
 }
 interface CommandHandlerContext {
-    context: RuntimeContext;
-    state: RuntimeState;
-    emit: (events: RuntimeEvent[]) => void;
-    requestVersionBump: () => number;
+  context: RuntimeContext;
+  state: RuntimeState;
+  emit: (events: RuntimeEvent[]) => void;
+  requestVersionBump: () => number;
 }
 type CommandHandler<TPayload = unknown, TResult = unknown> = (command: RuntimeCommand<TPayload>, ctx: CommandHandlerContext) => Awaitable<CommandResult<TResult>>;
 type QueryHandler<TPayload = unknown, TResult = unknown> = (query: RuntimeQuery<TPayload>, ctx: RuntimeContext) => Awaitable<QueryResult<TResult>>;
 interface RuntimeAdapters {
-    storage?: SnapshotStorage;
-    commands?: Record<string, CommandHandler>;
-    queries?: Record<string, QueryHandler>;
+  storage?: SnapshotStorage;
+  commands?: Record<string, CommandHandler>;
+  queries?: Record<string, QueryHandler>;
 }
-
+//#endregion
+//#region src/runtime/runtime.d.ts
 declare class FrpRuntime {
-    private readonly context;
-    private readonly storage?;
-    private readonly commandHandlers;
-    private readonly queryHandlers;
-    private eventBuffer;
-    private commandQueue;
-    private state;
-    constructor(context: RuntimeContext, adapters?: RuntimeAdapters);
-    registerCommand(name: string, handler: CommandHandler): void;
-    registerQuery(name: string, handler: QueryHandler): void;
-    execute<TPayload, TResult = unknown>(command: RuntimeCommand<TPayload>): Promise<CommandResult<TResult>>;
-    query<TPayload, TResult = unknown>(query: RuntimeQuery<TPayload>): Promise<QueryResult<TResult>>;
-    snapshot(): RuntimeState;
-    drainEvents(): RuntimeEvent[];
-    private runCommand;
-    private pushEvents;
-    private bumpVersion;
-    private persistSnapshot;
-    private normalizeError;
-    private buildError;
-    private now;
+  private readonly context;
+  private readonly storage?;
+  private readonly commandHandlers;
+  private readonly queryHandlers;
+  private eventBuffer;
+  private commandQueue;
+  private state;
+  constructor(context: RuntimeContext, adapters?: RuntimeAdapters);
+  registerCommand(name: string, handler: CommandHandler): void;
+  registerQuery(name: string, handler: QueryHandler): void;
+  execute<TPayload, TResult = unknown>(command: RuntimeCommand<TPayload>): Promise<CommandResult<TResult>>;
+  query<TPayload, TResult = unknown>(query: RuntimeQuery<TPayload>): Promise<QueryResult<TResult>>;
+  snapshot(): RuntimeState;
+  drainEvents(): RuntimeEvent[];
+  private runCommand;
+  private pushEvents;
+  private bumpVersion;
+  private persistSnapshot;
+  private normalizeError;
+  private buildError;
+  private now;
 }
-
+//#endregion
+//#region ../types/src/common.d.ts
 /**
- * Client-side node information collector
- * Gathers system information and reports to server via heartbeat
+ * FRP 通用配置类型定义
+ * 基于 frp 官方文档: https://gofrp.org/zh-cn/docs/reference/common/
  */
-
-interface ClientCollectorOptions {
-    /** Node ID (set by server after registration) */
-    nodeId?: string;
-    /** Heartbeat interval in milliseconds (default: 30000) */
-    heartbeatInterval?: number;
-    /** Logger instance */
-    logger?: {
-        debug?: (msg: string, data?: unknown) => void;
-        info?: (msg: string, data?: unknown) => void;
-        error?: (msg: string, error?: unknown) => void;
+/** 日志级别类型 */
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+/** 日志配置 */
+interface LogConfig {
+  /** 日志输出文件路径，如果为 console，则会将日志打印在标准输出中 */
+  to?: string;
+  /** 日志级别，可选值为 trace, debug, info, warn, error，默认级别为 info */
+  level?: LogLevel;
+  /** 日志文件最多保留天数，默认为 3 天 */
+  maxDays?: number;
+  /** 禁用标准输出中的日志颜色 */
+  disablePrintColor?: boolean;
+}
+/** TLS 配置 */
+interface TLSConfig {
+  /** TLS 证书文件路径 */
+  certFile: string;
+  /** TLS 密钥文件路径 */
+  keyFile: string;
+  /** CA 证书文件路径 */
+  trustedCaFile?: string;
+  /** TLS Server 名称 */
+  serverName?: string;
+}
+/** Web 服务器配置 */
+interface WebServerConfig {
+  /** webServer 监听地址，默认为 127.0.0.1 */
+  addr?: string;
+  /** webServer 监听端口 */
+  port: number;
+  /** HTTP BasicAuth 用户名 */
+  user?: string;
+  /** HTTP BasicAuth 密码 */
+  password?: string;
+  /** 静态资源目录，Dashboard 使用的资源默认打包在二进制文件中，通过指定此参数使用自定义的静态资源 */
+  assetsDir?: string;
+  /** 启动 Go HTTP pprof，用于应用调试 */
+  pprofEnable?: boolean;
+  /** Dashboard 启用 HTTPS 的 TLS 相关配置 */
+  tls?: TLSConfig;
+}
+/** QUIC 协议选项 */
+interface QUICOptions {
+  /** 保活周期，默认值为 10 秒 */
+  keepalivePeriod?: number;
+  /** 最大空闲超时时间，默认值为 30 秒 */
+  maxIdleTimeout?: number;
+  /** 最大传入流数量，默认值为 100000 */
+  maxIncomingStreams?: number;
+}
+/** 端口范围配置 */
+interface PortsRange {
+  /** 起始端口 */
+  start?: number;
+  /** 终止端口 */
+  end?: number;
+  /** 单一端口 */
+  single?: number;
+}
+/** 文件数据源配置 */
+interface FileSource {
+  /** 文件路径 */
+  path: string;
+}
+/** 数据源类型 */
+type ValueSourceType = 'file';
+/** 值数据源配置 */
+interface ValueSource {
+  /** 数据源类型，目前仅支持 "file" */
+  type: ValueSourceType;
+  /** 文件数据源配置，当 type 为 "file" 时必填 */
+  file?: FileSource;
+}
+//#endregion
+//#region ../types/src/server.d.ts
+/** 鉴权方式类型 */
+type AuthMethod = 'token' | 'oidc';
+/** 鉴权信息附加范围类型 */
+type AuthScope = 'HeartBeats' | 'NewWorkConns';
+/** OIDC 服务端鉴权配置 */
+interface AuthOIDCServerConfig {
+  /** OIDC 发行者 */
+  issuer?: string;
+  /** OIDC 受众 */
+  audience?: string;
+  /** 跳过过期检查 */
+  skipExpiryCheck?: boolean;
+  /** 跳过发行者检查 */
+  skipIssuerCheck?: boolean;
+}
+/** 服务端鉴权配置 */
+interface AuthServerConfig {
+  /** 鉴权方式，可选值为 token 或 oidc，默认为 token */
+  method?: AuthMethod;
+  /** 鉴权信息附加范围，可选值为 HeartBeats 和 NewWorkConns */
+  additionalScopes?: AuthScope[];
+  /** 在 method 为 token 时生效，客户端需要设置一样的值才能鉴权通过。与 tokenSource 字段互斥 */
+  token?: string;
+  /** 从文件中加载 token 的配置。与 token 字段互斥 */
+  tokenSource?: ValueSource;
+  /** oidc 鉴权配置 */
+  oidc?: AuthOIDCServerConfig;
+}
+/** 服务端 TLS 配置 */
+interface TLSServerConfig extends TLSConfig {
+  /** 是否只接受启用了 TLS 的客户端连接 */
+  force?: boolean;
+}
+/** 服务端传输层配置 */
+interface ServerTransportConfig {
+  /** tcp mux 的心跳检查间隔时间，单位秒 */
+  tcpMuxKeepaliveInterval?: number;
+  /** 和客户端底层 TCP 连接的 keepalive 间隔时间，单位秒，配置为负数表示不启用 */
+  tcpKeepalive?: number;
+  /** 允许客户端设置的最大连接池大小，如果客户端配置的值大于此值，会被强制修改为最大值，默认为 5 */
+  maxPoolCount?: number;
+  /** 服务端和客户端心跳连接的超时时间，单位秒，默认为 90 秒 */
+  heartbeatTimeout?: number;
+  /** QUIC 协议配置参数 */
+  quic?: QUICOptions;
+  /** 服务端 TLS 协议配置 */
+  tls?: TLSServerConfig;
+}
+/** HTTP 插件选项 */
+interface HTTPPluginOptions {
+  /** 插件名称 */
+  name: string;
+  /** 插件接口的地址 */
+  addr: string;
+  /** 插件接口的 Path */
+  path: string;
+  /** 插件需要生效的操作列表，具体可选值请参考服务端插件的说明文档 */
+  ops: string[];
+  /** 当插件地址为 HTTPS 协议时，是否校验插件的 TLS 证书，默认为不校验 */
+  tlsVerify?: boolean;
+}
+/** SSH 隧道网关配置 */
+interface SSHTunnelGateway {
+  /** SSH 服务器监听端口 */
+  bindPort: number;
+  /** SSH 服务器私钥文件路径。若为空，frps将读取autoGenPrivateKeyPath路径下的私钥文件 */
+  privateKeyFile?: string;
+  /** 私钥文件自动生成路径，默认为./.autogen_ssh_key。若文件不存在或内容为空，frps将自动生成RSA私钥文件并存储到该路径 */
+  autoGenPrivateKeyPath?: string;
+  /** SSH 客户端授权密钥文件路径。若为空，则不进行SSH客户端鉴权认证。非空可实现SSH免密登录认证 */
+  authorizedKeysFile?: string;
+}
+/** 服务端配置 */
+interface ServerConfig {
+  /** 鉴权配置 */
+  auth?: AuthServerConfig;
+  /** 服务端监听地址，用于接收 frpc 的连接，默认监听 0.0.0.0 */
+  bindAddr?: string;
+  /** 服务端监听端口，默认值为 7000 */
+  bindPort?: number;
+  /** 服务端监听 KCP 协议端口，用于接收配置了使用 KCP 协议的 frpc 连接 */
+  kcpBindPort?: number;
+  /** 服务端监听 QUIC 协议端口，用于接收配置了使用 QUIC 协议的 frpc 连接 */
+  quicBindPort?: number;
+  /** 代理监听地址，可以使代理监听在不同的网卡地址，默认情况下同 bindAddr */
+  proxyBindAddr?: string;
+  /** HTTP 类型代理监听的端口，启用后才能支持 HTTP 类型的代理 */
+  vhostHTTPPort?: number;
+  /** HTTP 类型代理在服务端的 ResponseHeader 超时时间，默认为 60s */
+  vhostHTTPTimeout?: number;
+  /** HTTPS 类型代理监听的端口，启用后才能支持 HTTPS 类型的代理 */
+  vhostHTTPSPort?: number;
+  /** tcpmux 类型且复用器为 httpconnect 的代理监听的端口 */
+  tcpmuxHTTPConnectPort?: number;
+  /** 对于 tcpmux 类型的代理是否透传 CONNECT 请求 */
+  tcpmuxPassthrough?: boolean;
+  /** 二级域名后缀 */
+  subDomainHost?: string;
+  /** 自定义 404 错误页面地址 */
+  custom404Page?: string;
+  /** ssh 隧道网关配置 */
+  sshTunnelGateway?: SSHTunnelGateway;
+  /** 服务端 Dashboard 配置 */
+  webServer?: WebServerConfig;
+  /** 是否提供 Prometheus 监控接口，需要同时启用了 webServer 后才会生效 */
+  enablePrometheus?: boolean;
+  /** 日志配置 */
+  log?: LogConfig;
+  /** 网络层配置 */
+  transport?: ServerTransportConfig;
+  /** 服务端返回详细错误信息给客户端，默认为 true */
+  detailedErrorsToClient?: boolean;
+  /** 限制单个客户端最大同时存在的代理数，默认无限制 */
+  maxPortsPerClient?: number;
+  /** 用户建立连接后等待客户端响应的超时时间，单位秒，默认为 10 秒 */
+  userConnTimeout?: number;
+  /** 代理 UDP 服务时支持的最大包长度，默认为 1500，服务端和客户端的值需要一致 */
+  udpPacketSize?: number;
+  /** 打洞策略数据的保留时间，默认为 168 小时，即 7 天 */
+  natholeAnalysisDataReserveHours?: number;
+  /** 允许代理绑定的服务端端口 */
+  allowPorts?: PortsRange[];
+  /** 服务端 HTTP 插件配置 */
+  httpPlugins?: HTTPPluginOptions[];
+}
+//#endregion
+//#region ../types/src/client.d.ts
+/** 客户端传输协议类型 */
+type ClientTransportProtocol = 'tcp' | 'kcp' | 'quic' | 'websocket' | 'wss';
+/** OIDC 客户端鉴权配置 */
+interface AuthOIDCClientConfig {
+  /** OIDC 客户端 ID */
+  clientID?: string;
+  /** OIDC 客户端密钥 */
+  clientSecret?: string;
+  /** OIDC audience 参数 */
+  audience?: string;
+  /** OIDC scope 参数 */
+  scope?: string;
+  /** OIDC 令牌端点 URL */
+  tokenEndpointURL?: string;
+  /** 附加的端点参数 */
+  additionalEndpointParams?: Record<string, string>;
+  /** 信任的 CA 证书文件路径，用于验证 OIDC 服务器的 TLS 证书 */
+  trustedCaFile?: string;
+  /** 跳过 TLS 证书验证，不推荐在生产环境使用 */
+  insecureSkipVerify?: boolean;
+  /** 访问 OIDC 令牌端点时使用的代理服务器 URL */
+  proxyURL?: string;
+}
+/** 客户端鉴权配置 */
+interface AuthClientConfig {
+  /** 鉴权方式，可选值为 token 或 oidc，默认为 token */
+  method?: AuthMethod;
+  /** 鉴权信息附加范围，可选值为 HeartBeats 和 NewWorkConns */
+  additionalScopes?: AuthScope[];
+  /** 在 method 为 token 时生效，客户端需要设置一样的值才能鉴权通过。与 tokenSource 字段互斥 */
+  token?: string;
+  /** 从文件中加载 token 的配置。与 token 字段互斥 */
+  tokenSource?: ValueSource;
+  /** oidc 鉴权配置 */
+  oidc?: AuthOIDCClientConfig;
+}
+/** 客户端 TLS 配置 */
+interface TLSClientConfig extends TLSConfig {
+  /** 是否和服务端之间启用 TLS 连接，默认启用 */
+  enable?: boolean;
+  /** 启用 TLS 连接时，不发送 0x17 特殊字节。默认为 true。当配置为 true 时，无法和 vhostHTTPSPort 端口复用 */
+  disableCustomTLSFirstByte?: boolean;
+}
+/** 客户端传输层配置 */
+interface ClientTransportConfig {
+  /** 和 frps 之间的通信协议，可选值为 tcp, kcp, quic, websocket, wss。默认为 tcp */
+  protocol?: ClientTransportProtocol;
+  /** 连接服务端的超时时间，默认为 10s */
+  dialServerTimeout?: number;
+  /** 和服务端底层 TCP 连接的 keepalive 间隔时间，单位秒 */
+  dialServerKeepalive?: number;
+  /** 连接服务端时所绑定的本地 IP */
+  connectServerLocalIP?: string;
+  /** 连接服务端使用的代理地址，格式为 {protocol}://user:passwd@192.168.1.128:8080 protocol 目前支持 http、socks5、ntlm */
+  proxyURL?: string;
+  /** 连接池大小 */
+  poolCount?: number;
+  /** TCP 多路复用，默认启用 */
+  tcpMux?: boolean;
+  /** tcp_mux 的心跳检查间隔时间 */
+  tcpMuxKeepaliveInterval?: number;
+  /** QUIC 协议配置参数 */
+  quic?: QUICOptions;
+  /** 向服务端发送心跳包的间隔时间，默认为 30s。建议启用 tcp_mux_keepalive_interval，将此值设置为 -1 */
+  heartbeatInterval?: number;
+  /** 和服务端心跳的超时时间，默认为 90s */
+  heartbeatTimeout?: number;
+  /** 客户端 TLS 协议配置 */
+  tls?: TLSClientConfig;
+}
+/** 虚拟网络配置 */
+interface VirtualNetConfig {
+  /** 虚拟网络接口的 IP 地址和网段，格式为 CIDR (例如 "100.86.0.1/24") */
+  address: string;
+}
+/** 客户端通用配置 */
+interface ClientCommonConfig {
+  /** 客户端鉴权配置 */
+  auth?: AuthClientConfig;
+  /** 用户名，设置此参数后，代理名称会被修改为 {user}.{proxyName}，避免代理名称和其他用户冲突 */
+  user?: string;
+  /** 连接服务端的地址 */
+  serverAddr?: string;
+  /** 连接服务端的端口，默认为 7000 */
+  serverPort?: number;
+  /** xtcp 打洞所需的 stun 服务器地址，默认为 stun.easyvoip.com:3478 */
+  natHoleStunServer?: string;
+  /** 使用 DNS 服务器地址，默认使用系统配置的 DNS 服务器，指定此参数可以强制替换为自定义的 DNS 服务器地址 */
+  dnsServer?: string;
+  /** 第一次登陆失败后是否退出，默认为 true */
+  loginFailExit?: boolean;
+  /** 指定启用部分代理，当配置了较多代理，但是只希望启用其中部分时可以通过此参数指定，默认为全部启用 */
+  start?: string[];
+  /** 日志配置 */
+  log?: LogConfig;
+  /** 客户端 AdminServer 配置 */
+  webServer?: WebServerConfig;
+  /** 客户端网络层配置 */
+  transport?: ClientTransportConfig;
+  /** 虚拟网络配置，Alpha 特性 */
+  virtualNet?: VirtualNetConfig;
+  /** 特性门控，用于启用或禁用实验性功能 */
+  featureGates?: Record<string, boolean>;
+  /** 代理 UDP 服务时支持的最大包长度，默认为 1500，服务端和客户端需要保持配置一致 */
+  udpPacketSize?: number;
+  /** 附加元数据，会传递给服务端插件，提供附加能力 */
+  metadatas?: Record<string, string>;
+  /** 指定额外的配置文件目录，其中的 proxy 和 visitor 配置会被读取加载 */
+  includes?: string[];
+}
+/** 客户端配置 */
+interface ClientConfig extends ClientCommonConfig {}
+//#endregion
+//#region ../types/src/proxy.d.ts
+/**
+ * FRP Proxy configuration types
+ * Based on: https://gofrp.org/zh-cn/docs/reference/proxy-config/
+ */
+/** Proxy type enum */
+declare enum ProxyType {
+  /** TCP proxy */
+  TCP = "tcp",
+  /** UDP proxy */
+  UDP = "udp",
+  /** HTTP proxy */
+  HTTP = "http",
+  /** HTTPS proxy */
+  HTTPS = "https",
+  /** TCP multiplexer proxy */
+  TCPMUX = "tcpmux",
+  /** Secure TCP proxy */
+  STCP = "stcp",
+  /** XTCP (P2P) proxy */
+  XTCP = "xtcp",
+  /** Secure UDP proxy */
+  SUDP = "sudp"
+}
+/** Load balancer strategy */
+type LoadBalancerStrategy = 'random' | 'round_robin';
+/** Base proxy configuration */
+interface BaseProxyConfig {
+  /** Proxy name (unique) */
+  name: string;
+  /** Proxy type */
+  type: ProxyType;
+  /** Local IP to bind */
+  localIP?: string;
+  /** Local port */
+  localPort?: number;
+  /** Additional metadata */
+  annotations?: Record<string, string>;
+  /** Custom metadata passed to server plugins */
+  metadatas?: Record<string, string>;
+  /** Load balancer settings */
+  loadBalancer?: {
+    /** Load balancing strategy */strategy?: LoadBalancerStrategy; /** Health check configuration */
+    healthCheck?: {
+      /** Health check type */type?: ProxyType.TCP | ProxyType.HTTP; /** Health check timeout (seconds) */
+      timeoutSeconds?: number; /** Max failed checks before marking unhealthy */
+      maxFailed?: number; /** Check interval (seconds) */
+      intervalSeconds?: number; /** HTTP health check path */
+      path?: string;
     };
+  };
+  /** Enable bandwidth limit */
+  transport?: {
+    /** Bandwidth limit (KB/s) */bandwidthLimit?: string; /** Bandwidth limit mode */
+    bandwidthLimitMode?: 'client' | 'server';
+  };
+}
+/** TCP proxy configuration */
+interface TCPProxyConfig extends BaseProxyConfig {
+  type: ProxyType.TCP;
+  /** Remote port on server */
+  remotePort?: number;
+}
+/** UDP proxy configuration */
+interface UDPProxyConfig extends BaseProxyConfig {
+  type: ProxyType.UDP;
+  /** Remote port on server */
+  remotePort?: number;
+}
+/** HTTP proxy configuration */
+interface HTTPProxyConfig extends BaseProxyConfig {
+  type: ProxyType.HTTP;
+  /** Custom domain names */
+  customDomains?: string[];
+  /** Subdomain under server's subdomain_host */
+  subdomain?: string;
+  /** Locations to proxy */
+  locations?: string[];
+  /** Host header rewrite */
+  hostHeaderRewrite?: string;
+  /** HTTP username for basic auth */
+  httpUser?: string;
+  /** HTTP password for basic auth */
+  httpPassword?: string;
+  /** Request headers to set */
+  requestHeaders?: {
+    set?: Record<string, string>;
+  };
+  /** Response headers to set */
+  responseHeaders?: {
+    set?: Record<string, string>;
+  };
+  /** Route by HTTP user */
+  routeByHTTPUser?: string;
+}
+/** HTTPS proxy configuration */
+interface HTTPSProxyConfig extends BaseProxyConfig {
+  type: ProxyType.HTTPS;
+  /** Custom domain names */
+  customDomains?: string[];
+  /** Subdomain under server's subdomain_host */
+  subdomain?: string;
+}
+/** TCPMUX proxy configuration */
+interface TCPMUXProxyConfig extends BaseProxyConfig {
+  type: ProxyType.TCPMUX;
+  /** Multiplexer type */
+  multiplexer?: 'httpconnect';
+  /** Custom domain names */
+  customDomains?: string[];
+  /** Subdomain under server's subdomain_host */
+  subdomain?: string;
+  /** Route by HTTP user */
+  routeByHTTPUser?: string;
+  /** HTTP username */
+  httpUser?: string;
+  /** HTTP password */
+  httpPassword?: string;
+}
+/** STCP proxy configuration */
+interface STCPProxyConfig extends BaseProxyConfig {
+  type: ProxyType.STCP;
+  /** Secret key shared with visitor */
+  secretKey?: string;
+  /** Allowed visitor users */
+  allowUsers?: string[];
+}
+/** XTCP proxy configuration */
+interface XTCPProxyConfig extends BaseProxyConfig {
+  type: ProxyType.XTCP;
+  /** Secret key shared with visitor */
+  secretKey?: string;
+  /** Allowed visitor users */
+  allowUsers?: string[];
+}
+/** SUDP proxy configuration */
+interface SUDPProxyConfig extends BaseProxyConfig {
+  type: ProxyType.SUDP;
+  /** Secret key shared with visitor */
+  secretKey?: string;
+  /** Allowed visitor users */
+  allowUsers?: string[];
+}
+/** Union type of all proxy configurations */
+type ProxyConfig = TCPProxyConfig | UDPProxyConfig | HTTPProxyConfig | HTTPSProxyConfig | TCPMUXProxyConfig | STCPProxyConfig | XTCPProxyConfig | SUDPProxyConfig;
+//#endregion
+//#region ../types/src/node.d.ts
+/** Node information structure */
+interface NodeInfo$1 {
+  id: string;
+  ip: string;
+  port: number;
+  protocol: 'tcp' | 'udp';
+  serverAddr: string;
+  serverPort: number;
+  hostname?: string;
+  osType?: string;
+  osRelease?: string;
+  platform?: string;
+  cpuCores?: number;
+  memTotal?: number;
+  frpVersion?: string;
+  bridgeVersion?: string;
+  status: 'online' | 'offline' | 'connecting' | 'error';
+  lastHeartbeat?: number;
+  connectedAt?: number;
+  labels?: Record<string, string>;
+  metadata?: Record<string, unknown>;
+  token?: string;
+  tunnels?: ProxyConfig[];
+  createdAt: number;
+  updatedAt: number;
+}
+/** Payload for node registration (Client → Server) */
+interface NodeRegisterPayload {
+  ip: string;
+  port: number;
+  serverAddr: string;
+  serverPort: number;
+  protocol: 'tcp' | 'udp';
+  hostname: string;
+  osType: string;
+  osRelease: string;
+  platform: string;
+  cpuCores: number;
+  memTotal: number;
+  frpVersion: string;
+  bridgeVersion: string;
+  token?: string;
+}
+/** Payload for node heartbeat (Client → Server) */
+interface NodeHeartbeatPayload {
+  nodeId: string;
+  status: 'online' | 'error';
+  lastHeartbeat: number;
+  cpuCores?: number;
+  memTotal?: number;
+}
+/** Payload for tunnel synchronization (Client → Server) */
+interface TunnelSyncPayload {
+  nodeId: string;
+  tunnels: ProxyConfig[];
+  timestamp: number;
+}
+/** Query parameters for listing nodes */
+interface NodeListQuery {
+  page?: number;
+  pageSize?: number;
+  status?: NodeInfo$1['status'];
+  labels?: Record<string, string>;
+  search?: string;
+}
+/** Response for node list query */
+interface NodeListResponse {
+  items: NodeInfo$1[];
+  total: number;
+  page: number;
+  pageSize: number;
+  hasMore: boolean;
+}
+/** Node statistics */
+interface NodeStatistics {
+  total: number;
+  online: number;
+  offline: number;
+  connecting: number;
+  error: number;
+}
+//#endregion
+//#region ../types/src/rpc.d.ts
+interface RpcRequest$1 {
+  id: string;
+  method: string;
+  params: Record<string, unknown>;
+  timeout?: number;
+}
+//#endregion
+//#region src/node/client-collector.d.ts
+interface ClientCollectorOptions {
+  /** Node ID (set by server after registration) */
+  nodeId?: string;
+  /** Heartbeat interval in milliseconds (default: 30000) */
+  heartbeatInterval?: number;
 }
 /**
  * Collects node information on client side
  * Used in client mode to send system info and heartbeat to server
  */
 declare class ClientNodeCollector {
-    private nodeId?;
-    private heartbeatInterval;
-    private logger;
-    private heartbeatTimer?;
-    constructor(options?: ClientCollectorOptions);
-    /** Set node ID after server registration */
-    setNodeId(nodeId: string): void;
-    /** Collect current node information */
-    collectNodeInfo(): Partial<NodeRegisterPayload>;
-    /** Collect heartbeat payload */
-    collectHeartbeat(): Partial<NodeHeartbeatPayload>;
-    /**
-     * Start periodic heartbeat collection
-     * Callback will be called at each interval with heartbeat payload
-     */
-    startHeartbeat(callback: (payload: Partial<NodeHeartbeatPayload>) => void, interval?: number): void;
-    /** Stop periodic heartbeat collection */
-    stopHeartbeat(): void;
-    /** Check if heartbeat is running */
-    isHeartbeatRunning(): boolean;
+  private nodeId?;
+  private heartbeatInterval;
+  private readonly log;
+  private heartbeatTimer?;
+  constructor(options?: ClientCollectorOptions);
+  /** Set node ID after server registration */
+  setNodeId(nodeId: string): void;
+  /** Collect current node information */
+  collectNodeInfo(): Partial<NodeRegisterPayload>;
+  /** Collect heartbeat payload */
+  collectHeartbeat(): Partial<NodeHeartbeatPayload>;
+  /**
+   * Start periodic heartbeat collection
+   * Callback will be called at each interval with heartbeat payload
+   */
+  startHeartbeat(callback: (payload: Partial<NodeHeartbeatPayload>) => void, interval?: number): void;
+  /** Stop periodic heartbeat collection */
+  stopHeartbeat(): void;
+  /** Check if heartbeat is running */
+  isHeartbeatRunning(): boolean;
 }
-
-/**
- * Node Manager for server-side node management
- * Handles node registration, heartbeat, tunnel registry, and queries
- */
-
+//#endregion
+//#region src/node/node-manager.d.ts
 interface NodeManagerOptions {
-    heartbeatTimeout?: number;
-    logger?: any;
+  heartbeatTimeout?: number;
 }
 interface NodeStorage {
-    save: (node: NodeInfo$1) => Promise<void> | void;
-    delete: (id: string) => Promise<void> | void;
-    load: (id: string) => Promise<NodeInfo$1 | undefined> | NodeInfo$1 | undefined;
-    list: () => Promise<NodeInfo$1[]> | NodeInfo$1[];
+  save: (node: NodeInfo$1) => Promise<void> | void;
+  delete: (id: string) => Promise<void> | void;
+  load: (id: string) => Promise<NodeInfo$1 | undefined> | NodeInfo$1 | undefined;
+  list: () => Promise<NodeInfo$1[]> | NodeInfo$1[];
 }
 type NodeEvent = 'node:registered' | 'node:heartbeat' | 'node:unregistered' | 'node:statusChanged' | 'tunnel:synced';
 /**
@@ -179,64 +721,60 @@ type NodeEvent = 'node:registered' | 'node:heartbeat' | 'node:unregistered' | 'n
  * Stores node info, handles heartbeat, manages global tunnel registry, emits events
  */
 declare class NodeManager extends EventEmitter {
-    private context;
-    private nodes;
-    private heartbeatTimers;
-    private tunnelRegistry;
-    private storage?;
-    private heartbeatTimeout;
-    private logger?;
-    constructor(context: RuntimeContext, options?: NodeManagerOptions, storage?: NodeStorage);
-    initialize(): Promise<void>;
-    /** Register a new node (called when client connects) */
-    registerNode(payload: NodeRegisterPayload): Promise<NodeInfo$1>;
-    /** Update node heartbeat and status */
-    updateHeartbeat(payload: NodeHeartbeatPayload): Promise<void>;
-    /** Unregister a node (called when client disconnects) */
-    unregisterNode(nodeId: string): Promise<void>;
-    /** Get node by id */
-    getNode(id: string): Promise<NodeInfo$1 | undefined>;
-    /** List nodes with pagination and filtering */
-    listNodes(query?: NodeListQuery): Promise<NodeListResponse>;
-    /** Get node statistics */
-    getStatistics(): Promise<NodeStatistics>;
-    /** Check if node exists */
-    hasNode(id: string): boolean;
-    /** Get all online nodes */
-    getOnlineNodes(): NodeInfo$1[];
-    /** Get all offline nodes */
-    getOfflineNodes(): NodeInfo$1[];
-    /** Get nodes by status */
-    getNodesByStatus(status: NodeInfo$1['status']): NodeInfo$1[];
-    /** Setup heartbeat timer for a node */
-    private setupHeartbeatTimer;
-    /** Clear heartbeat timer for a node */
-    private clearHeartbeatTimer;
-    /** Handle heartbeat timeout */
-    private handleHeartbeatTimeout;
-    /** Sync tunnels for a node (called when node connects or updates tunnels) */
-    syncTunnels(payload: TunnelSyncPayload): Promise<void>;
-    /** Get tunnels for a specific node */
-    getNodeTunnels(nodeId: string): ProxyConfig[];
-    /** Get all tunnels across all nodes */
-    getAllTunnels(): Map<string, ProxyConfig[]>;
-    /** Check if a remotePort is in use across all nodes (for conflict detection) */
-    isRemotePortInUse(remotePort: number, excludeNodeId?: string): {
-        inUse: boolean;
-        nodeId?: string;
-        tunnelName?: string;
-    };
-    /** Clear tunnels for a node (called when node disconnects) */
-    private clearNodeTunnels;
-    /** Update dispose method to clear tunnels */
-    dispose(): Promise<void>;
+  private context;
+  private nodes;
+  private heartbeatTimers;
+  private tunnelRegistry;
+  private storage?;
+  private heartbeatTimeout;
+  private readonly log;
+  constructor(context: RuntimeContext, options?: NodeManagerOptions, storage?: NodeStorage);
+  initialize(): Promise<void>;
+  /** Register a new node (called when client connects) */
+  registerNode(payload: NodeRegisterPayload): Promise<NodeInfo$1>;
+  /** Update node heartbeat and status */
+  updateHeartbeat(payload: NodeHeartbeatPayload): Promise<void>;
+  /** Unregister a node (called when client disconnects) */
+  unregisterNode(nodeId: string): Promise<void>;
+  /** Get node by id */
+  getNode(id: string): Promise<NodeInfo$1 | undefined>;
+  /** List nodes with pagination and filtering */
+  listNodes(query?: NodeListQuery): Promise<NodeListResponse>;
+  /** Get node statistics */
+  getStatistics(): Promise<NodeStatistics>;
+  /** Check if node exists */
+  hasNode(id: string): boolean;
+  /** Get all online nodes */
+  getOnlineNodes(): NodeInfo$1[];
+  /** Get all offline nodes */
+  getOfflineNodes(): NodeInfo$1[];
+  /** Get nodes by status */
+  getNodesByStatus(status: NodeInfo$1['status']): NodeInfo$1[];
+  /** Setup heartbeat timer for a node */
+  private setupHeartbeatTimer;
+  /** Clear heartbeat timer for a node */
+  private clearHeartbeatTimer;
+  /** Handle heartbeat timeout */
+  private handleHeartbeatTimeout;
+  /** Sync tunnels for a node (called when node connects or updates tunnels) */
+  syncTunnels(payload: TunnelSyncPayload): Promise<void>;
+  /** Get tunnels for a specific node */
+  getNodeTunnels(nodeId: string): ProxyConfig[];
+  /** Get all tunnels across all nodes */
+  getAllTunnels(): Map<string, ProxyConfig[]>;
+  /** Check if a remotePort is in use across all nodes (for conflict detection) */
+  isRemotePortInUse(remotePort: number, excludeNodeId?: string): {
+    inUse: boolean;
+    nodeId?: string;
+    tunnelName?: string;
+  };
+  /** Clear tunnels for a node (called when node disconnects) */
+  private clearNodeTunnels;
+  /** Update dispose method to clear tunnels */
+  dispose(): Promise<void>;
 }
-
-/**
- * File-based node storage implementation
- * Persists node information to disk
- */
-
+//#endregion
+//#region src/node/file-node-storage.d.ts
 /**
  * Stores nodes in JSON files
  * Directory structure:
@@ -245,214 +783,683 @@ declare class NodeManager extends EventEmitter {
  *   └── node-{id}.json (individual node data)
  */
 declare class FileNodeStorage implements NodeStorage {
-    private storagePath;
-    private indexPath;
-    private nodeDir;
-    constructor(storagePath: string);
-    /** Save or update a node */
-    save(node: NodeInfo$1): Promise<void>;
-    /** Delete a node */
-    delete(id: string): Promise<void>;
-    /** Load a single node */
-    load(id: string): Promise<NodeInfo$1 | undefined>;
-    /** Load all nodes */
-    list(): Promise<NodeInfo$1[]>;
-    /** Update the index of node IDs */
-    private updateIndex;
+  private storagePath;
+  private indexPath;
+  private nodeDir;
+  constructor(storagePath: string);
+  /** Save or update a node */
+  save(node: NodeInfo$1): Promise<void>;
+  /** Delete a node */
+  delete(id: string): Promise<void>;
+  /** Load a single node */
+  load(id: string): Promise<NodeInfo$1 | undefined>;
+  /** Load all nodes */
+  list(): Promise<NodeInfo$1[]>;
+  /** Update the index of node IDs */
+  private updateIndex;
 }
-
+//#endregion
+//#region src/config-merger.d.ts
 /**
- * FRP process management utilities
+ * 预设配置接口
  */
-
+interface PresetConfig {
+  frps?: FrpsPresetConfig;
+  frpc?: FrpcPresetConfig;
+}
+interface FrpsPresetConfig {
+  bindPort?: number;
+  vhostHTTPPort?: number;
+  vhostHTTPSPort?: number;
+  domain?: string;
+  dashboardPort?: number;
+  dashboardUser?: string;
+  dashboardPassword?: string;
+  authToken?: string;
+  subdomainHost?: string;
+}
+interface FrpcPresetConfig {
+  serverAddr?: string;
+  serverPort?: number;
+  authToken?: string;
+  user?: string;
+  heartbeatInterval?: number;
+}
+/**
+ * 默认预设配置
+ */
+declare const DEFAULT_PRESET_CONFIG: PresetConfig;
+/**
+ * 合并预设配置和用户配置，生成最终的 TOML 配置
+ */
+declare function mergeConfigs(presetConfig: PresetConfig, userConfig: string, type: 'frps' | 'frpc'): string;
+/**
+ * 从 tunnels 数组生成并保存 FRP 配置文件
+ */
+declare function saveFrpConfigFile(configPath: string, tunnels: ProxyConfig[], presetConfig: PresetConfig, type: 'frps' | 'frpc'): Promise<void>;
+/**
+ * 将配置对象转换为 TOML 格式
+ */
+declare function configToToml(config: Record<string, unknown>): string;
+/**
+ * 验证预设配置
+ */
+declare function validatePresetConfig(config: PresetConfig, type: 'frps' | 'frpc'): {
+  valid: boolean;
+  errors: string[];
+};
+//#endregion
+//#region src/process/controllers/process-controller.d.ts
+type ProcessEventType = 'process:started' | 'process:stopped' | 'process:exited' | 'process:error' | 'status';
+//#endregion
+//#region src/process/index.d.ts
+interface ProcessEvent {
+  type: ProcessEventType;
+  timestamp: number;
+  payload?: {
+    code?: number;
+    signal?: string;
+    error?: string;
+    pid?: number;
+    uptime?: number;
+    running?: boolean;
+  };
+}
 interface FrpProcessManagerOptions {
-    /** Working directory for FRP files */
-    workDir?: string;
-    /** Path to config file (overrides default) */
-    configPath?: string;
-    /** FRP version (defaults to latest) */
-    version?: string;
-    /** Mode: client or server */
-    mode: 'client' | 'server';
-    /** Optional logger */
-    logger?: RuntimeLogger;
+  /** Working directory for FRP files */
+  workDir?: string;
+  /** Path to config file (overrides default) */
+  configPath?: string;
+  /** Config directory for preset configs (overrides workDir/config) */
+  configDir?: string;
+  /** FRP version (defaults to latest) */
+  version?: string;
+  /** Mode: client or server */
+  mode: 'client' | 'server';
 }
 interface NodeInfo {
-    /** Node ID */
-    id: string;
-    /** Node name */
-    name: string;
-    /** Server address */
-    serverAddr: string;
-    /** Server port */
-    serverPort?: number;
-    /** Authentication token */
-    token?: string;
-    /** Additional config */
-    config?: Partial<ClientConfig | ServerConfig>;
+  /** Node ID */
+  id: string;
+  /** Node name */
+  name: string;
+  /** Server address */
+  serverAddr: string;
+  /** Server port */
+  serverPort?: number;
+  /** Authentication token */
+  token?: string;
+  /** Additional config */
+  config?: Partial<ClientConfig | ServerConfig>;
 }
 /**
  * Manages FRP client/server lifecycle, config, and tunnels
+ *
+ * This class now serves as a facade that delegates to specialized components:
+ * - ProcessController: Process lifecycle management
+ * - ConfigurationStore: Configuration file operations
+ * - TunnelManager: Tunnel/proxy management
+ * - NodeManager: Node information management
+ * - BinaryManager: Binary file management
  */
 declare class FrpProcessManager extends EventEmitter {
-    private readonly workDir;
-    private version;
-    private readonly mode;
-    private readonly specifiedVersion?;
-    private readonly logger;
-    private process;
-    private configPath;
-    private binaryPath;
-    private uptime;
-    private isManualStop;
-    constructor(options: FrpProcessManagerOptions);
-    /** Ensure version is fetched and binary path is set */
-    private ensureVersion;
-    /** Download FRP binary for current platform */
-    downloadFrpBinary(): Promise<void>;
-    /** Update FRP binary to latest version */
-    updateFrpBinary(newVersion?: string): Promise<void>;
-    /** Check if binary exists */
-    hasBinary(): boolean;
-    /** Get current configuration */
-    getConfig(): ClientConfig | ServerConfig | null;
-    /** Update configuration */
-    updateConfig(config: Partial<ClientConfig | ServerConfig>): void;
-    /** Backup configuration */
-    backupConfig(): Promise<string>;
-    /** Return the absolute config file path */
-    getConfigPath(): string;
-    /** Read raw config file contents */
-    getConfigRaw(): string | null;
-    /** Overwrite config file with provided content */
-    updateConfigRaw(content: string): void;
-    /** Start FRP process */
-    start(): Promise<void>;
-    /** Stop FRP process */
-    stop(): Promise<void>;
-    /** Check if process is running */
-    isRunning(): boolean;
-    /** Add node (for client mode) */
-    addNode(node: NodeInfo): void;
-    /** Get node info */
-    getNode(): NodeInfo | null;
-    /** Update node info */
-    updateNode(node: Partial<NodeInfo>): void;
-    /** Remove node */
-    removeNode(): void;
-    /** Add tunnel (proxy) */
-    addTunnel(proxy: ProxyConfig): void;
-    /** Check if proxy type uses remotePort */
-    private typeUsesRemotePort;
-    /** Get tunnel by name */
-    getTunnel(name: string): ProxyConfig | null;
-    /** Update tunnel */
-    updateTunnel(name: string, proxy: Partial<ProxyConfig>): void;
-    /** Remove tunnel */
-    removeTunnel(name: string): void;
-    /** List all tunnels */
-    listTunnels(): ProxyConfig[];
-    /**
-     * Query current process status
-     */
-    queryProcess(): {
-        pid: number | undefined;
-        uptime: number;
-    };
-    private setupProcessListeners;
+  private readonly workDir;
+  private readonly mode;
+  private readonly specifiedVersion?;
+  private readonly configPath;
+  private readonly configDir;
+  private readonly processController;
+  private readonly configStore;
+  private readonly binaryManager;
+  private readonly presetConfigManager;
+  private tunnelManager;
+  private nodeManager;
+  private uptime;
+  private isManualStop;
+  constructor(options: FrpProcessManagerOptions);
+  /** Ensure version is fetched and binary path is set */
+  private ensureVersion;
+  /** Download FRP binary for current platform */
+  downloadFrpBinary(): Promise<void>;
+  /** Update FRP binary to latest version */
+  updateFrpBinary(newVersion?: string): Promise<void>;
+  /** Check if binary exists */
+  hasBinary(): boolean;
+  /** Get current configuration */
+  getConfig(): Promise<ClientConfig | ServerConfig | null>;
+  /** Update configuration */
+  updateConfig(config: Partial<ClientConfig | ServerConfig>): Promise<void>;
+  /** Backup configuration */
+  backupConfig(): Promise<string>;
+  /** Return the absolute config file path */
+  getConfigPath(): string;
+  /** Read raw config file contents */
+  getConfigRaw(): string | null;
+  /** Overwrite config file with provided content */
+  updateConfigRaw(content: string): void;
+  /** Start FRP process */
+  start(): Promise<void>;
+  /** Stop FRP process */
+  stop(): Promise<void>;
+  /** Check if process is running */
+  isRunning(): boolean;
+  /** Add node (for client mode) */
+  addNode(node: NodeInfo): Promise<void>;
+  /** Get node info */
+  getNode(): Promise<NodeInfo | null>;
+  /** Update node info */
+  updateNode(node: Partial<NodeInfo>): Promise<void>;
+  /** Remove node */
+  removeNode(): Promise<void>;
+  /** Add tunnel (proxy) */
+  addTunnel(proxy: ProxyConfig): Promise<void>;
+  /** Get tunnel by name */
+  getTunnel(name: string): Promise<ProxyConfig | null>;
+  /** Update tunnel */
+  updateTunnel(name: string, proxy: Partial<ProxyConfig>): Promise<void>;
+  /** Remove tunnel */
+  removeTunnel(name: string): Promise<void>;
+  /** List all tunnels */
+  listTunnels(): Promise<ProxyConfig[]>;
+  /**
+   * 生成 FRP 配置文件（合并预设配置和用户 tunnels）
+   * @param force 是否强制重新生成
+   */
+  generateConfig(force?: boolean): Promise<void>;
+  /**
+   * 获取预设配置
+   */
+  getPresetConfig(): PresetConfig;
+  /**
+   * 保存预设配置
+   */
+  savePresetConfig(config: Record<string, any>): void;
+  /**
+   * Query current process status
+   */
+  queryProcess(): {
+    pid?: number;
+    uptime: number;
+  };
+  /**
+   * Dispose and clean up resources
+   */
+  dispose(): Promise<void>;
 }
-
+//#endregion
+//#region src/rpc/message-types.d.ts
+/**
+ * RPC 消息类型定义
+ * 提供类型安全的消息结构和类型守卫
+ */
+/**
+ * RPC 消息类型枚举
+ */
+declare enum RpcMessageType {
+  REGISTER = "register",
+  COMMAND = "command",
+  RESPONSE = "response",
+  PING = "ping",
+  PONG = "pong"
+}
+/**
+ * 节点注册消息
+ */
+interface RegisterMessage {
+  type: RpcMessageType.REGISTER;
+  nodeId: string;
+  payload: Record<string, unknown>;
+}
+/**
+ * RPC 请求
+ */
+interface RpcRequest {
+  id: string;
+  method: string;
+  params: Record<string, unknown>;
+  timeout?: number;
+}
+/**
+ * RPC 响应状态
+ */
+type RpcResponseStatus = 'success' | 'error';
+/**
+ * RPC 响应
+ */
+interface RpcResponse {
+  id: string;
+  status: RpcResponseStatus;
+  result?: unknown;
+  error?: {
+    code: string;
+    message: string;
+  };
+}
+/**
+ * Ping 消息
+ */
+interface PingMessage {
+  type: RpcMessageType.PING;
+  timestamp: number;
+}
+/**
+ * Pong 消息
+ */
+interface PongMessage {
+  type: RpcMessageType.PONG;
+  timestamp: number;
+}
+/**
+ * 所有 RPC 消息类型
+ */
+type RpcMessage = RegisterMessage | RpcRequest | RpcResponse | PingMessage | PongMessage;
+/**
+ * Event-based RPC message type (matching document spec)
+ */
+interface EventRpcMessage {
+  type: 'command' | 'event';
+  action: string;
+  payload: unknown;
+  id?: string;
+  targetNodeId?: string;
+  [key: string]: unknown;
+}
+/**
+ * Command message (frps -> frpc)
+ */
+interface CommandRpcMessage extends EventRpcMessage {
+  type: 'command';
+  id: string;
+}
+/**
+ * Event message (frpc -> frps)
+ */
+interface EventRpcMessageEvent extends EventRpcMessage {
+  type: 'event';
+  id?: string;
+}
+/**
+ * Tunnel add payload
+ */
+interface TunnelAddPayload {
+  name: string;
+  type: 'tcp' | 'http' | 'https' | 'stcp' | 'sudp' | 'xtcp';
+  localPort: number;
+  remotePort?: number;
+  customDomains?: string[];
+  subdomain?: string;
+  nodeId?: string;
+  [key: string]: unknown;
+}
+/**
+ * Tunnel delete payload
+ */
+interface TunnelDeletePayload {
+  name: string;
+  nodeId?: string;
+}
+/**
+ * Tunnel response payload
+ */
+interface TunnelResponsePayload {
+  success: boolean;
+  error?: string;
+  tunnel?: TunnelAddPayload;
+}
+/**
+ * Node delete payload
+ */
+interface NodeDeletePayload {
+  name: string;
+}
+/**
+ * Node response payload
+ */
+interface NodeResponsePayload {
+  success: boolean;
+  error?: string;
+  deletedNode?: string;
+}
+/**
+ * All message types including event-based
+ */
+type AllRpcMessage = RpcMessage | EventRpcMessage;
+/**
+ * 类型守卫：检查是否为注册消息
+ */
+declare function isRegisterMessage(msg: unknown): msg is RegisterMessage;
+/**
+ * 类型守卫：检查是否为 RPC 请求
+ */
+declare function isRpcRequest(msg: unknown): msg is RpcRequest;
+/**
+ * 类型守卫：检查是否为 RPC 响应
+ */
+declare function isRpcResponse(msg: unknown): msg is RpcResponse;
+/**
+ * 类型守卫：检查是否为 Ping 消息
+ */
+declare function isPingMessage(msg: unknown): msg is PingMessage;
+/**
+ * 类型守卫：检查是否为 Pong 消息
+ */
+declare function isPongMessage(msg: unknown): msg is PongMessage;
+/**
+ * 类型守卫：检查是否为 Event-based RPC 消息
+ */
+declare function isEventRpcMessage(msg: unknown): msg is EventRpcMessage;
+/**
+ * 类型守卫：检查是否为 Command 消息
+ */
+declare function isCommandMessage(msg: unknown): msg is CommandRpcMessage;
+/**
+ * 类型守卫：检查是否为 Event 消息
+ */
+declare function isEventMessage(msg: unknown): msg is EventRpcMessageEvent;
+/**
+ * 类型守卫：检查是否为 TunnelAddPayload
+ */
+declare function isTunnelAddPayload(data: unknown): data is TunnelAddPayload;
+/**
+ * 类型守卫：检查是否为 TunnelDeletePayload
+ */
+declare function isTunnelDeletePayload(data: unknown): data is TunnelDeletePayload;
+/**
+ * 类型守卫：检查是否为 NodeDeletePayload
+ */
+declare function isNodeDeletePayload(data: unknown): data is NodeDeletePayload;
+//#endregion
+//#region src/rpc/middleware.d.ts
+/**
+ * 中间件上下文
+ */
+interface MiddlewareContext {
+  request: RpcRequest;
+  response: Partial<RpcResponse>;
+  startTime: number;
+}
+/**
+ * 中间件函数类型
+ */
+type MiddlewareFn = (context: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+/**
+ * 中间件选项
+ */
+interface MiddlewareOptions {
+  preHooks?: MiddlewareFn[];
+  postHooks?: MiddlewareFn[];
+}
+/**
+ * 日志中间件
+ */
+declare function loggingMiddleware(): MiddlewareFn;
+/**
+ * 认证中间件
+ */
+declare function authMiddleware(validateToken: (token: string | undefined) => boolean | Promise<boolean>): MiddlewareFn;
+/**
+ * 超时中间件
+ */
+declare function timeoutMiddleware(timeoutMs: number): MiddlewareFn;
+/**
+ * 错误处理中间件
+ */
+declare function errorHandlerMiddleware(): MiddlewareFn;
+/**
+ * 中间件管道
+ */
+declare class MiddlewarePipeline {
+  private middlewares;
+  /**
+   * 添加中间件
+   */
+  use(middleware: MiddlewareFn): this;
+  /**
+   * 执行中间件管道
+   */
+  execute(request: RpcRequest, handler: () => Promise<unknown>): Promise<Partial<RpcResponse>>;
+  /**
+   * 执行处理器
+   */
+  private executeHandler;
+  /**
+   * 清空中间件
+   */
+  clear(): void;
+}
+//#endregion
+//#region src/rpc/reconnect-strategy.d.ts
+/**
+ * RPC 重连策略
+ * 提供可配置的重连机制，包括指数退避
+ */
+/**
+ * 重连策略接口
+ */
+interface ReconnectStrategy {
+  /**
+   * 判断是否应该重连
+   */
+  shouldReconnect: (attempt: number) => boolean;
+  /**
+   * 获取重连延迟时间（毫秒）
+   */
+  getDelay: (attempt: number) => number;
+  /**
+   * 达到最大重连次数时的回调
+   */
+  onMaxAttemptsReached: () => void;
+}
+/**
+ * 指数退避重连策略
+ */
+declare class ExponentialBackoffStrategy implements ReconnectStrategy {
+  private maxAttempts;
+  private baseDelay;
+  private maxDelay;
+  constructor(maxAttempts?: number, baseDelay?: number, maxDelay?: number);
+  shouldReconnect(attempt: number): boolean;
+  getDelay(attempt: number): number;
+  onMaxAttemptsReached(): void;
+}
+/**
+ * 固定间隔重连策略
+ */
+declare class FixedIntervalStrategy implements ReconnectStrategy {
+  private maxAttempts;
+  private interval;
+  constructor(maxAttempts?: number, interval?: number);
+  shouldReconnect(attempt: number): boolean;
+  getDelay(): number;
+  onMaxAttemptsReached(): void;
+}
+/**
+ * 线性增长重连策略
+ */
+declare class LinearBackoffStrategy implements ReconnectStrategy {
+  private maxAttempts;
+  private baseDelay;
+  private increment;
+  private maxDelay;
+  constructor(maxAttempts?: number, baseDelay?: number, increment?: number, maxDelay?: number);
+  shouldReconnect(attempt: number): boolean;
+  getDelay(attempt: number): number;
+  onMaxAttemptsReached(): void;
+}
+/**
+ * 无限重连策略（永不停止）
+ */
+declare class InfiniteReconnectStrategy implements ReconnectStrategy {
+  private baseDelay;
+  private maxDelay;
+  constructor(baseDelay?: number, maxDelay?: number);
+  shouldReconnect(): boolean;
+  getDelay(attempt: number): number;
+  onMaxAttemptsReached(): void;
+}
+//#endregion
+//#region src/rpc/rpc-client.d.ts
 interface RpcClientOptions {
-    url: string;
-    nodeId: string;
-    getRegisterPayload: () => Promise<NodeInfo$1> | NodeInfo$1;
-    handleRequest: (req: RpcRequest) => Promise<unknown>;
-    reconnectInterval?: number;
-    logger?: {
-        info?: (msg: string, data?: unknown) => void;
-        warn?: (msg: string, data?: unknown) => void;
-        error?: (msg: string, data?: unknown) => void;
-    };
+  url: string;
+  nodeId: string;
+  getRegisterPayload: () => Promise<NodeInfo$1> | NodeInfo$1;
+  handleRequest: (req: RpcRequest$1) => Promise<unknown>;
+  handleCommand?: (command: CommandRpcMessage) => Promise<unknown>;
+  reconnectStrategy?: ReconnectStrategy;
 }
 declare class RpcClient {
-    private readonly options;
-    private ws;
-    private reconnectTimer?;
-    private readonly reconnectInterval;
-    constructor(options: RpcClientOptions);
-    connect(): Promise<void>;
-    disconnect(): void;
-    private createConnection;
-    private handleMessage;
-    private handleRpcRequest;
-    private send;
-    private scheduleReconnect;
+  private readonly options;
+  private ws;
+  private reconnectTimer?;
+  private reconnectAttempt;
+  private readonly reconnectStrategy;
+  private connectionState;
+  private readonly log;
+  constructor(options: RpcClientOptions);
+  connect(): Promise<void>;
+  disconnect(): void;
+  /**
+   * Get current connection state
+   */
+  getConnectionState(): 'connecting' | 'connected' | 'disconnected';
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean;
+  /**
+   * Send an event message to server (matching document spec)
+   */
+  sendEvent(event: EventRpcMessageEvent): boolean;
+  private createConnection;
+  private handleMessage;
+  /**
+   * Handle event-based command messages from server (matching document spec)
+   */
+  private handleCommandEvent;
+  private handleRpcRequest;
+  private send;
+  private scheduleReconnect;
+}
+//#endregion
+//#region src/rpc/rpc-server.d.ts
+/**
+ * Command status for tracking
+ */
+interface RpcCommandStatus {
+  commandId: string;
+  nodeId: string;
+  action: string;
+  status: 'pending' | 'completed' | 'failed';
+  result?: unknown;
+  error?: string;
+  timestamp: number;
 }
-
 interface RpcServerOptions {
-    port: number;
-    heartbeatInterval?: number;
-    logger?: {
-        info?: (msg: string, data?: unknown) => void;
-        warn?: (msg: string, data?: unknown) => void;
-        error?: (msg: string, data?: unknown) => void;
-    };
-    validateToken?: (token: string | undefined, nodeId: string | undefined) => boolean | Promise<boolean>;
-    authorize?: (nodeId: string, method: string) => boolean | Promise<boolean>;
-    onRegister?: (nodeId: string, payload: NodeInfo$1) => void | Promise<void>;
+  port: number;
+  heartbeatInterval?: number;
+  validateToken?: (token: string | undefined, nodeId: string | undefined) => boolean | Promise<boolean>;
+  authorize?: (nodeId: string, method: string) => boolean | Promise<boolean>;
+  onRegister?: (nodeId: string, payload: NodeInfo$1) => void | Promise<void>;
+  onEvent?: (nodeId: string, event: EventRpcMessage) => void | Promise<void>;
+  commandTimeout?: number;
 }
 declare class RpcServer {
-    private readonly options;
-    private readonly clients;
-    private readonly pendingRequests;
-    private readonly wsToNode;
-    private heartbeatTimer?;
-    private server?;
-    constructor(options: RpcServerOptions);
-    start(): void;
-    stop(): void;
-    rpcCall(nodeId: string, method: string, params: Record<string, unknown>, timeout?: number): Promise<unknown>;
-    private handleMessage;
-    private handleRpcResponse;
-    private handleClose;
-    private startHeartbeat;
+  private readonly options;
+  private readonly clients;
+  private readonly pendingRequests;
+  private readonly commandStatuses;
+  private readonly commandTimers;
+  private readonly wsToNode;
+  private heartbeatTimer?;
+  private cleanupTimer?;
+  private server?;
+  private readonly defaultCommandTimeout;
+  private readonly log;
+  constructor(options: RpcServerOptions);
+  start(): void;
+  stop(): void;
+  rpcCall(nodeId: string, method: string, params: Record<string, unknown>, timeout?: number): Promise<unknown>;
+  /**
+   * Send event-based message to a specific node (matching document spec)
+   */
+  sendToNode(nodeId: string, message: EventRpcMessage): boolean;
+  /**
+   * Broadcast event-based message to all connected nodes
+   */
+  broadcast(message: EventRpcMessage): void;
+  /**
+   * Get list of all online node IDs
+   */
+  getOnlineNodes(): string[];
+  /**
+   * Check if a specific node is online
+   */
+  isNodeOnline(nodeId: string): boolean;
+  /**
+   * Get the count of online nodes
+   */
+  getOnlineNodeCount(): number;
+  /**
+   * Get command status by ID
+   */
+  getRpcCommandStatus(commandId: string): RpcCommandStatus | undefined;
+  /**
+   * Get all command statuses
+   */
+  getAllRpcCommandStatuses(): RpcCommandStatus[];
+  /**
+   * Clear completed/failed command statuses older than specified milliseconds
+   */
+  clearOldStatuses(maxAge?: number): void;
+  private handleMessage;
+  /**
+   * Handle event-based messages from clients
+   */
+  private handleEventMessage;
+  private handleRegister;
+  private handleRpcResponse;
+  private handleClose;
+  private startHeartbeat;
 }
-
+//#endregion
+//#region src/bridge/initializer.d.ts
 interface FrpBridgeRuntimeOptions {
-    id?: string;
-    mode?: RuntimeMode;
-    logger?: RuntimeLogger;
-    clock?: () => number;
-    platform?: string;
-    workDir?: string;
+  id?: string;
+  mode?: RuntimeMode;
+  clock?: () => number;
+  platform?: string;
+  workDir?: string;
 }
 interface FrpBridgeProcessOptions extends Partial<Omit<FrpProcessManagerOptions, 'mode'>> {
-    mode?: 'client' | 'server';
+  mode?: 'client' | 'server';
 }
 interface FrpBridgeRpcOptions {
-    serverPort?: number;
-    serverHeartbeatInterval?: number;
-    serverValidateToken?: (token: string | undefined, nodeId: string | undefined) => boolean | Promise<boolean>;
-    serverAuthorize?: (nodeId: string, method: string) => boolean | Promise<boolean>;
-    clientUrl?: string;
-    clientNodeId?: string;
-    clientToken?: string;
-    clientReconnectInterval?: number;
-    getRegisterPayload?: () => Promise<NodeInfo$1> | NodeInfo$1;
-    handleRequest?: (req: RpcRequest) => Promise<unknown>;
+  serverPort?: number;
+  serverHeartbeatInterval?: number;
+  serverValidateToken?: (token: string | undefined, nodeId: string | undefined) => boolean | Promise<boolean>;
+  serverAuthorize?: (nodeId: string, method: string) => boolean | Promise<boolean>;
+  serverOnRegister?: (nodeId: string, payload: NodeInfo$1) => void | Promise<void>;
+  serverOnEvent?: (nodeId: string, event: EventRpcMessage) => void | Promise<void>;
+  serverCommandTimeout?: number;
+  clientUrl?: string;
+  clientNodeId?: string;
+  clientToken?: string;
+  clientReconnectInterval?: number;
+  getRegisterPayload?: () => Promise<NodeInfo$1> | NodeInfo$1;
+  handleRequest?: (req: RpcRequest$1) => Promise<unknown>;
 }
-
+//#endregion
+//#region src/bridge/index.d.ts
 interface FrpBridgeOptions {
-    mode: 'client' | 'server';
-    workDir?: string;
-    configPath?: string;
-    runtime?: FrpBridgeRuntimeOptions;
-    process?: FrpBridgeProcessOptions;
-    rpc?: FrpBridgeRpcOptions;
-    storage?: SnapshotStorage;
-    commands?: Record<string, CommandHandler>;
-    queries?: Record<string, QueryHandler>;
-    eventSink?: (event: RuntimeEvent) => void;
+  mode: 'client' | 'server';
+  workDir?: string;
+  configPath?: string;
+  runtime?: FrpBridgeRuntimeOptions;
+  process?: FrpBridgeProcessOptions;
+  rpc?: FrpBridgeRpcOptions;
+  storage?: SnapshotStorage;
+  commands?: Record<string, CommandHandler>;
+  queries?: Record<string, QueryHandler>;
+  eventSink?: (event: RuntimeEvent) => void;
 }
 /**
  * FrpBridge - Main facade class for managing FRP bridge operations.
@@ -469,51 +1476,52 @@ interface FrpBridgeOptions {
  * - Factory Pattern: Handlers created via factory functions
  */
 declare class FrpBridge {
-    private readonly runtime;
-    private readonly process;
-    private readonly mode;
-    private readonly eventSink?;
-    private readonly nodeManager?;
-    private readonly clientCollector?;
-    private readonly rpcServer?;
-    private readonly rpcClient?;
-    constructor(options: FrpBridgeOptions);
-    /**
-     * Execute a command
-     */
-    execute<TPayload, TResult = unknown>(command: RuntimeCommand<TPayload>): Promise<CommandResult<TResult>>;
-    /**
-     * Execute a query
-     */
-    query<TPayload, TResult = unknown>(query: RuntimeQuery<TPayload>): Promise<QueryResult<TResult>>;
-    /**
-     * Get current runtime state snapshot
-     */
-    snapshot(): RuntimeState;
-    /**
-     * Drain and return all pending events
-     */
-    drainEvents(): RuntimeEvent[];
-    getProcessManager(): FrpProcessManager;
-    getRuntime(): FrpRuntime;
-    getNodeManager(): NodeManager | undefined;
-    getClientCollector(): ClientNodeCollector | undefined;
-    getRpcServer(): RpcServer | undefined;
-    getRpcClient(): RpcClient | undefined;
-    /**
-     * Initialize all async components
-     */
-    initialize(): Promise<void>;
-    /**
-     * Cleanup and dispose all resources
-     */
-    dispose(): Promise<void>;
-    /**
-     * Forward runtime events to external event sink
-     */
-    private forwardEvents;
+  private readonly runtime;
+  private readonly process;
+  private readonly mode;
+  private readonly eventSink?;
+  private readonly nodeManager?;
+  private readonly clientCollector?;
+  private readonly rpcServer?;
+  private readonly rpcClient?;
+  constructor(options: FrpBridgeOptions);
+  /**
+   * Execute a command
+   */
+  execute<TPayload, TResult = unknown>(command: RuntimeCommand<TPayload>): Promise<CommandResult<TResult>>;
+  /**
+   * Execute a query
+   */
+  query<TPayload, TResult = unknown>(query: RuntimeQuery<TPayload>): Promise<QueryResult<TResult>>;
+  /**
+   * Get current runtime state snapshot
+   */
+  snapshot(): RuntimeState;
+  /**
+   * Drain and return all pending events
+   */
+  drainEvents(): RuntimeEvent[];
+  getProcessManager(): FrpProcessManager;
+  getRuntime(): FrpRuntime;
+  getNodeManager(): NodeManager | undefined;
+  getClientCollector(): ClientNodeCollector | undefined;
+  getRpcServer(): RpcServer | undefined;
+  getRpcClient(): RpcClient | undefined;
+  /**
+   * Initialize all async components
+   */
+  initialize(): Promise<void>;
+  /**
+   * Cleanup and dispose all resources
+   */
+  dispose(): Promise<void>;
+  /**
+   * Forward runtime events to external event sink
+   */
+  private forwardEvents;
 }
-
+//#endregion
+//#region src/constants/index.d.ts
 /**
  * Core constants
  */
@@ -523,69 +1531,218 @@ declare const GITHUB_OWNER = "fatedier";
 declare const GITHUB_REPO = "frp";
 /** Platform-specific binary names */
 declare const BINARY_NAMES: {
-    readonly client: "frpc.exe" | "frpc";
-    readonly server: "frps.exe" | "frps";
+  readonly client: "frpc.exe" | "frpc";
+  readonly server: "frps.exe" | "frps";
 };
 /** Platform architecture mapping */
 declare const ARCH_MAP: Record<string, string>;
 /** Platform OS mapping */
 declare const OS_MAP: Record<string, string>;
-
-/** Custom error for FRP Bridge operations */
-declare class FrpBridgeError extends Error {
-    readonly code: string;
-    readonly details?: unknown | undefined;
-    constructor(message: string, code: string, details?: unknown | undefined);
-}
-/** Error codes */
-declare enum ErrorCode {
-    BINARY_NOT_FOUND = "BINARY_NOT_FOUND",
-    DOWNLOAD_FAILED = "DOWNLOAD_FAILED",
-    EXTRACTION_FAILED = "EXTRACTION_FAILED",
-    CONFIG_NOT_FOUND = "CONFIG_NOT_FOUND",
-    CONFIG_INVALID = "CONFIG_INVALID",
-    PROCESS_ALREADY_RUNNING = "PROCESS_ALREADY_RUNNING",
-    PROCESS_NOT_RUNNING = "PROCESS_NOT_RUNNING",
-    PROCESS_START_FAILED = "PROCESS_START_FAILED",
-    UNSUPPORTED_PLATFORM = "UNSUPPORTED_PLATFORM",
-    VERSION_FETCH_FAILED = "VERSION_FETCH_FAILED",
-    MODE_ERROR = "MODE_ERROR",
-    NOT_FOUND = "NOT_FOUND"
+//#endregion
+//#region src/errors/base-error.d.ts
+/**
+ * Base error class for all FRP Bridge errors
+ * Provides consistent error structure and handling
+ */
+declare abstract class FrpBridgeErrorBase extends Error {
+  /**
+   * Error code for programmatic error handling
+   */
+  abstract readonly code: string;
+  /**
+   * HTTP status code (optional, for API responses)
+   */
+  readonly statusCode?: number;
+  /**
+   * Additional error details
+   */
+  readonly details?: unknown;
+  constructor(message: string, details?: unknown);
+  /**
+   * Convert error to plain object for serialization
+   */
+  toJSON(): {
+    code: string;
+    message: string;
+    statusCode?: number;
+    details?: unknown;
+  };
 }
-
+/**
+ * Generic error for uncategorized errors
+ */
+declare class GenericError extends FrpBridgeErrorBase {
+  readonly code: string;
+  constructor(message: string, code: string, details?: unknown);
+}
+//#endregion
+//#region src/errors/categories.d.ts
+/**
+ * Configuration errors (400 Bad Request)
+ */
+declare class ConfigNotFoundError extends FrpBridgeErrorBase {
+  readonly code = "CONFIG_NOT_FOUND";
+  readonly statusCode = 400;
+}
+declare class ConfigInvalidError extends FrpBridgeErrorBase {
+  readonly code = "CONFIG_INVALID";
+  readonly statusCode = 400;
+}
+/**
+ * Process errors
+ */
+declare class ProcessNotRunningError extends FrpBridgeErrorBase {
+  readonly code = "PROCESS_NOT_RUNNING";
+  readonly statusCode = 409;
+}
+declare class ProcessAlreadyRunningError extends FrpBridgeErrorBase {
+  readonly code = "PROCESS_ALREADY_RUNNING";
+  readonly statusCode = 409;
+}
+declare class ProcessStartFailedError extends FrpBridgeErrorBase {
+  readonly code = "PROCESS_START_FAILED";
+  readonly statusCode = 500;
+}
+/**
+ * Binary errors (500 Internal Server Error)
+ */
+declare class BinaryNotFoundError extends FrpBridgeErrorBase {
+  readonly code = "BINARY_NOT_FOUND";
+  readonly statusCode = 500;
+}
+declare class DownloadFailedError extends FrpBridgeErrorBase {
+  readonly code = "DOWNLOAD_FAILED";
+  readonly statusCode = 500;
+}
+declare class ExtractionFailedError extends FrpBridgeErrorBase {
+  readonly code = "EXTRACTION_FAILED";
+  readonly statusCode = 500;
+}
+/**
+ * Network/Version errors (503 Service Unavailable)
+ */
+declare class VersionFetchError extends FrpBridgeErrorBase {
+  readonly code = "VERSION_FETCH_FAILED";
+  readonly statusCode = 503;
+}
+/**
+ * Validation errors (400 Bad Request)
+ */
+declare class ValidationError extends FrpBridgeErrorBase {
+  readonly code = "VALIDATION_ERROR";
+  readonly statusCode = 400;
+}
+/**
+ * Mode/State errors (409 Conflict)
+ */
+declare class ModeError extends FrpBridgeErrorBase {
+  readonly code = "MODE_ERROR";
+  readonly statusCode = 409;
+}
+/**
+ * Resource not found (404 Not Found)
+ */
+declare class NotFoundError extends FrpBridgeErrorBase {
+  readonly code = "NOT_FOUND";
+  readonly statusCode = 404;
+}
+/**
+ * Platform errors (500 Internal Server Error)
+ */
+declare class PlatformError extends FrpBridgeErrorBase {
+  readonly code = "UNSUPPORTED_PLATFORM";
+  readonly statusCode = 500;
+}
+//#endregion
+//#region src/runtime/file-snapshot-storage.d.ts
 declare class FileSnapshotStorage implements SnapshotStorage {
-    private readonly directory;
-    constructor(directory: string);
-    save(snapshot: ConfigSnapshot): Promise<void>;
-    load(version: number): Promise<ConfigSnapshot | undefined>;
-    list(): Promise<ConfigSnapshot[]>;
-    private buildPath;
+  private readonly directory;
+  constructor(directory: string);
+  save(snapshot: ConfigSnapshot): Promise<void>;
+  load(version: number): Promise<ConfigSnapshot | undefined>;
+  list(): Promise<ConfigSnapshot[]>;
+  private buildPath;
 }
-
+//#endregion
+//#region src/toml/index.d.ts
 /**
- * Utility functions
+ * Unified TOML parsing and serialization module
+ * Wraps smol-toml with consistent error handling
  */
+interface ParseOptions {
+  /**
+   * Parse integers as BigInt
+   */
+  integersAsBigInt?: boolean | 'asNeeded';
+}
+interface StringifyOptions {
+  /**
+   * Serialize numbers as floats
+   */
+  numbersAsFloat?: boolean;
+}
+/**
+ * Parse TOML string to JavaScript object
+ * @param content - TOML string content
+ * @param options - Parse options
+ * @returns Parsed JavaScript object
+ * @throws {Error} If TOML is invalid
+ */
+declare function parse<T = Record<string, any>>(content: string, options?: ParseOptions): T;
+/**
+ * Serialize JavaScript object to TOML string
+ * @param obj - JavaScript object to serialize
+ * @param options - Stringify options
+ * @returns TOML string
+ * @throws {Error} If object contains unserializable values
+ */
+declare function stringify(obj: Record<string, any>, options?: StringifyOptions): string;
+/**
+ * Check if a string is valid TOML
+ * @param content - String content to check
+ * @returns true if valid TOML, false otherwise
+ */
+declare function isValidToml(content: string): boolean;
+/**
+ * Parse TOML file content safely (returns null on error)
+ * @param content - TOML string content
+ * @returns Parsed object or null if parsing fails
+ */
+declare function safeParse<T = Record<string, any>>(content: string): T | null;
+//#endregion
+//#region src/utils/proxy-utils.d.ts
+/**
+ * Proxy/_tunnel related utility functions
+ */
+/**
+ * Check if proxy type uses remotePort field
+ */
+declare function typeUsesRemotePort(type: string): boolean;
+//#endregion
+//#region src/utils/index.d.ts
 /** Get latest FRP version from GitHub releases */
 declare function getLatestVersion(): Promise<string>;
 /** Get platform identifier for FRP release */
 declare function getPlatform(): string;
 /** Get GitHub release download URL */
 declare function getDownloadUrl(version: string, platform: string): string;
-/** Download file from URL */
-declare function downloadFile(url: string, dest: string): Promise<void>;
+/** Download file from URL with redirect limit */
+declare function downloadFile(url: string, dest: string, maxRedirects?: number): Promise<void>;
 /** Execute command */
 declare function executeCommand(command: string): Promise<{
-    stdout: string;
-    stderr: string;
+  stdout: string;
+  stderr: string;
 }>;
 /** Check if command exists */
 declare function commandExists(command: string): Promise<boolean>;
 /** Ensure directory exists */
 declare function ensureDir(dirPath: string): void;
-/** Parse TOML-like config to JSON */
-declare function parseToml(content: string): Record<string, any>;
-/** Convert JSON to TOML-like config */
-declare function toToml(obj: Record<string, any>): string;
-
-export { ARCH_MAP, BINARY_NAMES, ClientNodeCollector, ErrorCode, FileNodeStorage, FileSnapshotStorage, FrpBridge, FrpBridgeError, FrpProcessManager, FrpRuntime, GITHUB_OWNER, GITHUB_REPO, NodeManager, OS_MAP, RpcClient, RpcServer, commandExists, downloadFile, ensureDir, executeCommand, getDownloadUrl, getLatestVersion, getPlatform, parseToml, toToml };
-export type { Awaitable, ClientCollectorOptions, CommandHandler, CommandHandlerContext, CommandMetadata, CommandResult, CommandStatus, ConfigSnapshot, FrpBridgeOptions, FrpProcessManagerOptions, NodeEvent, NodeInfo, NodeManagerOptions, NodeStorage, QueryHandler, QueryResult, RpcClientOptions, RpcServerOptions, RuntimeAdapters, RuntimeCommand, RuntimeContext, RuntimeError, RuntimeErrorCode, RuntimeEvent, RuntimeLogger, RuntimeMode, RuntimeQuery, RuntimeState, RuntimeStatus, SnapshotStorage };
+/** Find existing FRP version in work directory */
+declare function findExistingVersion(workDir: string): string | null;
+/**
+ * Omit undefined values from an object
+ * Returns a new object with only defined values
+ */
+declare function omitUndefined<T extends Record<string, unknown>>(obj: T): T;
+//#endregion
+export { ARCH_MAP, AllRpcMessage, Awaitable, BINARY_NAMES, BinaryNotFoundError, type ClientCollectorOptions, ClientNodeCollector, CommandHandler, CommandHandlerContext, CommandMetadata, CommandResult, CommandRpcMessage, CommandStatus, ConfigInvalidError, ConfigNotFoundError, ConfigSnapshot, DEFAULT_PRESET_CONFIG, DownloadFailedError, FrpBridgeErrorBase as Error, FrpBridgeErrorBase, EventRpcMessage, EventRpcMessageEvent, ExponentialBackoffStrategy, ExtractionFailedError, FileNodeStorage, FileSnapshotStorage, FixedIntervalStrategy, FrpBridge, type FrpBridgeOptions, FrpProcessManager, type FrpProcessManagerOptions, FrpRuntime, FrpcPresetConfig, FrpsPresetConfig, GITHUB_OWNER, GITHUB_REPO, GenericError, InfiniteReconnectStrategy, LinearBackoffStrategy, MiddlewareContext, MiddlewareFn, MiddlewareOptions, MiddlewarePipeline, ModeError, NodeDeletePayload, type NodeEvent, type NodeInfo, NodeManager, type NodeManagerOptions, NodeResponsePayload, type NodeStorage, NotFoundError, OS_MAP, ParseOptions, PingMessage, PlatformError, PongMessage, PresetConfig, ProcessAlreadyRunningError, type ProcessEvent, type ProcessEventType, ProcessNotRunningError, ProcessStartFailedError, QueryHandler, QueryResult, ReconnectStrategy, RegisterMessage, RpcClient, RpcClientOptions, RpcCommandStatus, RpcMessage, RpcMessageType, RpcRequest, RpcResponse, RpcResponseStatus, RpcServer, RpcServerOptions, RuntimeAdapters, RuntimeCommand, RuntimeContext, RuntimeError, RuntimeErrorCode, RuntimeEvent, RuntimeLogger, RuntimeMode, RuntimeQuery, RuntimeState, RuntimeStatus, SnapshotStorage, StringifyOptions, TunnelAddPayload, TunnelDeletePayload, TunnelResponsePayload, ValidationError, VersionFetchError, authMiddleware, commandExists, configToToml, downloadFile, ensureDir, errorHandlerMiddleware, executeCommand, findExistingVersion, getDownloadUrl, getLatestVersion, getPlatform, isCommandMessage, isEventMessage, isEventRpcMessage, isNodeDeletePayload, isPingMessage, isPongMessage, isRegisterMessage, isRpcRequest, isRpcResponse, isTunnelAddPayload, isTunnelDeletePayload, isValidToml, loggingMiddleware, mergeConfigs, omitUndefined, parse, safeParse, saveFrpConfigFile, stringify, timeoutMiddleware, typeUsesRemotePort, validatePresetConfig };