@frp-bridge/core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 imba97 <https://github.com/imba97>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,317 @@
+import { ClientConfig, ServerConfig, ProxyConfig } from '@frp-bridge/types';
+
+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;
+}
+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;
+}
+interface RuntimeState {
+    status: RuntimeStatus;
+    version: number;
+    lastAppliedAt?: number;
+    lastError?: RuntimeError;
+}
+interface CommandMetadata {
+    requestId?: string;
+    correlationId?: string;
+    author?: string;
+    issuedAt?: number;
+}
+interface RuntimeCommand<TPayload = unknown> {
+    name: string;
+    payload: TPayload;
+    metadata?: CommandMetadata;
+}
+interface CommandResult<TResult = unknown> {
+    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;
+}
+interface QueryResult<TResult = unknown> {
+    result: TResult;
+    version: number;
+}
+interface RuntimeEvent<TPayload = unknown> {
+    type: string;
+    timestamp: number;
+    version?: number;
+    payload?: TPayload;
+}
+interface RuntimeError {
+    code: RuntimeErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+}
+type RuntimeErrorCode = 'VALIDATION_ERROR' | 'RUNTIME_ERROR' | 'SYSTEM_ERROR';
+interface ConfigSnapshot {
+    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[]>;
+}
+interface CommandHandlerContext {
+    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>;
+}
+
+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;
+}
+
+/**
+ * FRP process management utilities
+ */
+
+interface FrpProcessManagerOptions {
+    /** Working directory for FRP files */
+    workDir?: string;
+    /** FRP version (defaults to latest) */
+    version?: string;
+    /** Mode: client or server */
+    mode: 'client' | 'server';
+    /** Optional logger */
+    logger?: RuntimeLogger;
+}
+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>;
+}
+/**
+ * Manages FRP client/server lifecycle, config, and tunnels
+ */
+declare class FrpProcessManager {
+    private readonly workDir;
+    private version;
+    private readonly mode;
+    private readonly specifiedVersion?;
+    private readonly logger;
+    private process;
+    private configPath;
+    private binaryPath;
+    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 */
+    readConfigFile(): string | null;
+    /** Overwrite config file with provided content */
+    writeConfigFile(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;
+    /** 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[];
+}
+
+interface FrpBridgeRuntimeOptions {
+    id?: string;
+    mode?: RuntimeMode;
+    logger?: RuntimeLogger;
+    clock?: () => number;
+    platform?: string;
+    workDir?: string;
+}
+interface FrpBridgeProcessOptions extends Partial<Omit<FrpProcessManagerOptions, 'mode'>> {
+    mode?: 'client' | 'server';
+    workDir?: string;
+}
+interface FrpBridgeOptions {
+    mode: 'client' | 'server';
+    workDir?: string;
+    runtime?: FrpBridgeRuntimeOptions;
+    process?: FrpBridgeProcessOptions;
+    storage?: SnapshotStorage;
+    commands?: Record<string, CommandHandler>;
+    queries?: Record<string, QueryHandler>;
+    eventSink?: (event: RuntimeEvent) => void;
+}
+declare class FrpBridge {
+    private readonly options;
+    private readonly runtime;
+    private readonly process;
+    private readonly eventSink?;
+    constructor(options: FrpBridgeOptions);
+    execute<TPayload, TResult = unknown>(command: RuntimeCommand<TPayload>): Promise<CommandResult<TResult>>;
+    query<TPayload, TResult = unknown>(query: RuntimeQuery<TPayload>): Promise<QueryResult<TResult>>;
+    snapshot(): RuntimeState;
+    drainEvents(): RuntimeEvent[];
+    getProcessManager(): FrpProcessManager;
+    getRuntime(): FrpRuntime;
+    private createDefaultCommands;
+    private createDefaultQueries;
+    private forwardEvents;
+    private runConfigMutation;
+}
+
+/**
+ * Core constants
+ */
+/** GitHub repository owner */
+declare const GITHUB_OWNER = "fatedier";
+/** GitHub repository name */
+declare const GITHUB_REPO = "frp";
+/** Platform-specific binary names */
+declare const BINARY_NAMES: {
+    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"
+}
+
+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;
+}
+
+/**
+ * Utility functions
+ */
+/** 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>;
+/** Execute command */
+declare function executeCommand(command: string): Promise<{
+    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, ErrorCode, FileSnapshotStorage, FrpBridge, FrpBridgeError, FrpProcessManager, FrpRuntime, GITHUB_OWNER, GITHUB_REPO, OS_MAP, commandExists, downloadFile, ensureDir, executeCommand, getDownloadUrl, getLatestVersion, getPlatform, parseToml, toToml };
+export type { Awaitable, CommandHandler, CommandHandlerContext, CommandMetadata, CommandResult, CommandStatus, ConfigSnapshot, FrpBridgeOptions, FrpProcessManagerOptions, NodeInfo, QueryHandler, QueryResult, RuntimeAdapters, RuntimeCommand, RuntimeContext, RuntimeError, RuntimeErrorCode, RuntimeEvent, RuntimeLogger, RuntimeMode, RuntimeQuery, RuntimeState, RuntimeStatus, SnapshotStorage };

package/dist/index.d.ts

@@ -0,0 +1,317 @@
+import { ClientConfig, ServerConfig, ProxyConfig } from '@frp-bridge/types';
+
+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;
+}
+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;
+}
+interface RuntimeState {
+    status: RuntimeStatus;
+    version: number;
+    lastAppliedAt?: number;
+    lastError?: RuntimeError;
+}
+interface CommandMetadata {
+    requestId?: string;
+    correlationId?: string;
+    author?: string;
+    issuedAt?: number;
+}
+interface RuntimeCommand<TPayload = unknown> {
+    name: string;
+    payload: TPayload;
+    metadata?: CommandMetadata;
+}
+interface CommandResult<TResult = unknown> {
+    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;
+}
+interface QueryResult<TResult = unknown> {
+    result: TResult;
+    version: number;
+}
+interface RuntimeEvent<TPayload = unknown> {
+    type: string;
+    timestamp: number;
+    version?: number;
+    payload?: TPayload;
+}
+interface RuntimeError {
+    code: RuntimeErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+}
+type RuntimeErrorCode = 'VALIDATION_ERROR' | 'RUNTIME_ERROR' | 'SYSTEM_ERROR';
+interface ConfigSnapshot {
+    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[]>;
+}
+interface CommandHandlerContext {
+    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>;
+}
+
+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;
+}
+
+/**
+ * FRP process management utilities
+ */
+
+interface FrpProcessManagerOptions {
+    /** Working directory for FRP files */
+    workDir?: string;
+    /** FRP version (defaults to latest) */
+    version?: string;
+    /** Mode: client or server */
+    mode: 'client' | 'server';
+    /** Optional logger */
+    logger?: RuntimeLogger;
+}
+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>;
+}
+/**
+ * Manages FRP client/server lifecycle, config, and tunnels
+ */
+declare class FrpProcessManager {
+    private readonly workDir;
+    private version;
+    private readonly mode;
+    private readonly specifiedVersion?;
+    private readonly logger;
+    private process;
+    private configPath;
+    private binaryPath;
+    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 */
+    readConfigFile(): string | null;
+    /** Overwrite config file with provided content */
+    writeConfigFile(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;
+    /** 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[];
+}
+
+interface FrpBridgeRuntimeOptions {
+    id?: string;
+    mode?: RuntimeMode;
+    logger?: RuntimeLogger;
+    clock?: () => number;
+    platform?: string;
+    workDir?: string;
+}
+interface FrpBridgeProcessOptions extends Partial<Omit<FrpProcessManagerOptions, 'mode'>> {
+    mode?: 'client' | 'server';
+    workDir?: string;
+}
+interface FrpBridgeOptions {
+    mode: 'client' | 'server';
+    workDir?: string;
+    runtime?: FrpBridgeRuntimeOptions;
+    process?: FrpBridgeProcessOptions;
+    storage?: SnapshotStorage;
+    commands?: Record<string, CommandHandler>;
+    queries?: Record<string, QueryHandler>;
+    eventSink?: (event: RuntimeEvent) => void;
+}
+declare class FrpBridge {
+    private readonly options;
+    private readonly runtime;
+    private readonly process;
+    private readonly eventSink?;
+    constructor(options: FrpBridgeOptions);
+    execute<TPayload, TResult = unknown>(command: RuntimeCommand<TPayload>): Promise<CommandResult<TResult>>;
+    query<TPayload, TResult = unknown>(query: RuntimeQuery<TPayload>): Promise<QueryResult<TResult>>;
+    snapshot(): RuntimeState;
+    drainEvents(): RuntimeEvent[];
+    getProcessManager(): FrpProcessManager;
+    getRuntime(): FrpRuntime;
+    private createDefaultCommands;
+    private createDefaultQueries;
+    private forwardEvents;
+    private runConfigMutation;
+}
+
+/**
+ * Core constants
+ */
+/** GitHub repository owner */
+declare const GITHUB_OWNER = "fatedier";
+/** GitHub repository name */
+declare const GITHUB_REPO = "frp";
+/** Platform-specific binary names */
+declare const BINARY_NAMES: {
+    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"
+}
+
+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;
+}
+
+/**
+ * Utility functions
+ */
+/** 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>;
+/** Execute command */
+declare function executeCommand(command: string): Promise<{
+    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, ErrorCode, FileSnapshotStorage, FrpBridge, FrpBridgeError, FrpProcessManager, FrpRuntime, GITHUB_OWNER, GITHUB_REPO, OS_MAP, commandExists, downloadFile, ensureDir, executeCommand, getDownloadUrl, getLatestVersion, getPlatform, parseToml, toToml };
+export type { Awaitable, CommandHandler, CommandHandlerContext, CommandMetadata, CommandResult, CommandStatus, ConfigSnapshot, FrpBridgeOptions, FrpProcessManagerOptions, NodeInfo, QueryHandler, QueryResult, RuntimeAdapters, RuntimeCommand, RuntimeContext, RuntimeError, RuntimeErrorCode, RuntimeEvent, RuntimeLogger, RuntimeMode, RuntimeQuery, RuntimeState, RuntimeStatus, SnapshotStorage };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import{homedir as F}from"node:os";import p from"node:process";import{consola as _}from"consola";import{join as d}from"pathe";import{exec as W,spawn as G}from"node:child_process";import{createWriteStream as H,existsSync as f,mkdirSync as z,chmodSync as Y,readFileSync as m,writeFileSync as O,unlinkSync as Q}from"node:fs";import{get as J}from"node:http";import{get as C}from"node:https";import{promisify as X}from"node:util";import{writeFile as K,readFile as S,readdir as Z}from"node:fs/promises";const P="fatedier",D="frp",g={client:p.platform==="win32"?"frpc.exe":"frpc",server:p.platform==="win32"?"frps.exe":"frps"},I={x64:"amd64",arm64:"arm64",arm:"arm",ia32:"386"},$={win32:"windows",darwin:"darwin",linux:"linux",freebsd:"freebsd"};class u extends Error{constructor(t,e,s){super(t),this.code=e,this.details=s,this.name="FrpBridgeError"}}var c=(r=>(r.BINARY_NOT_FOUND="BINARY_NOT_FOUND",r.DOWNLOAD_FAILED="DOWNLOAD_FAILED",r.EXTRACTION_FAILED="EXTRACTION_FAILED",r.CONFIG_NOT_FOUND="CONFIG_NOT_FOUND",r.CONFIG_INVALID="CONFIG_INVALID",r.PROCESS_ALREADY_RUNNING="PROCESS_ALREADY_RUNNING",r.PROCESS_NOT_RUNNING="PROCESS_NOT_RUNNING",r.PROCESS_START_FAILED="PROCESS_START_FAILED",r.UNSUPPORTED_PLATFORM="UNSUPPORTED_PLATFORM",r.VERSION_FETCH_FAILED="VERSION_FETCH_FAILED",r.MODE_ERROR="MODE_ERROR",r.NOT_FOUND="NOT_FOUND",r))(c||{});const N=X(W);async function A(){const r=`https://api.github.com/repos/${P}/${D}/releases/latest`;return new Promise((t,e)=>{C(r,{headers:{"User-Agent":"frp-bridge"}},s=>{if(s.statusCode!==200){e(new Error(`Failed to fetch latest version: ${s.statusCode}`));return}let n="";s.on("data",i=>n+=i),s.on("end",()=>{try{const i=JSON.parse(n).tag_name?.replace(/^v/,"")||"0.65.0";t(i)}catch(i){e(i)}})}).on("error",e)})}function k(){const r=$[p.platform],t=I[p.arch];if(!r||!t)throw new Error(`Unsupported platform: ${p.platform}-${p.arch}`);return`${r}_${t}`}function U(r,t){const e=t.startsWith("windows_")?"zip":"tar.gz";return`https://github.com/${P}/${D}/releases/download/v${r}/frp_${r}_${t}.${e}`}async function T(r,t){return new Promise((e,s)=>{const n=H(t);(r.startsWith("https")?C:J)(r,i=>{if(i.statusCode===302||i.statusCode===301){const o=i.headers.location;if(o){n.close(),T(o,t).then(e).catch(s);return}}if(i.statusCode!==200){s(new Error(`Failed to download: ${i.statusCode}`));return}i.pipe(n),n.on("finish",()=>{n.close(),e()})}).on("error",i=>{n.close(),s(i)})})}async function b(r){return N(r)}async function R(r){try{return p.platform==="win32"?await N(`where ${r}`):await N(`which ${r}`),!0}catch{return!1}}function l(r){f(r)||z(r,{recursive:!0})}function w(r){const t=r.split(`
+`),e={};let s="";for(const n of t){const i=n.trim();if(!i||i.startsWith("#"))continue;if(i.startsWith("[")&&i.endsWith("]")){s=i.slice(1,-1),e[s]||(e[s]={});continue}const o=i.indexOf("=");if(o>0){const h=i.slice(0,o).trim();let a=i.slice(o+1).trim();(a.startsWith('"')&&a.endsWith('"')||a.startsWith("'")&&a.endsWith("'"))&&(a=a.slice(1,-1)),a==="true"?a=!0:a==="false"?a=!1:Number.isNaN(Number(a))||(a=Number(a)),s?e[s][h]=a:e[h]=a}}return e}function E(r){const t=[];for(const[e,s]of Object.entries(r))(typeof s!="object"||s===null||Array.isArray(s))&&t.push(L(e,s));for(const[e,s]of Object.entries(r))if(typeof s=="object"&&s!==null&&!Array.isArray(s)){t.push(""),t.push(`[${e}]`);for(const[n,i]of Object.entries(s))t.push(L(n,i))}return t.join(`
+`)}function L(r,t){return typeof t=="string"?`${r} = "${t}"`:typeof t=="boolean"||typeof t=="number"?`${r} = ${t}`:Array.isArray(t)?`${r} = [${t.map(e=>typeof e=="string"?`"${e}"`:e).join(", ")}]`:`${r} = "${String(t)}"`}class M{workDir;version=null;mode;specifiedVersion;logger;process=null;configPath;binaryPath;constructor(t){this.mode=t.mode,this.specifiedVersion=t.version,this.workDir=t.workDir||d(F(),".frp-bridge"),this.logger=t.logger??_.withTag("FrpProcessManager"),l(this.workDir),this.configPath=d(this.workDir,`frp${this.mode==="client"?"c":"s"}.toml`),this.binaryPath=""}async ensureVersion(){if(!this.version){this.version=this.specifiedVersion||await A();const t=this.mode==="client"?g.client:g.server;this.binaryPath=d(this.workDir,"bin",this.version,t)}}async downloadFrpBinary(){await this.ensureVersion();const t=k(),e=U(this.version,t),s=t.startsWith("windows_"),n=s?"zip":"tar.gz",i=d(this.workDir,`frp_${this.version}.${n}`),o=d(this.workDir,"bin",this.version);l(o),await T(e,i);const h=d(this.workDir,"temp");if(l(h),s){if(!await R("unzip"))throw new u("unzip is required for extraction on Windows",c.EXTRACTION_FAILED);await b(`unzip -o "${i}" -d "${h}"`)}else{const j=await R("gzip"),q=await R("tar");if(!j||!q)throw new u("gzip and tar are required for extraction",c.EXTRACTION_FAILED);await b(`tar -xzf "${i}" -C "${h}"`)}const a=d(h,`frp_${this.version}_${t}`),y=d(a,this.mode==="client"?g.client:g.server);if(!f(y))throw new u(`Binary not found: ${y}`,c.BINARY_NOT_FOUND);const v=await import("fs-extra");await v.copy(y,this.binaryPath),s||Y(this.binaryPath,493),await v.remove(i),await v.remove(h)}async updateFrpBinary(t){await this.ensureVersion();const e=t||await A();if(e===this.version)return;if(f(this.binaryPath)){const n=`${this.binaryPath}.bak`;await(await import("fs-extra")).copy(this.binaryPath,n)}this.version=e;const s=this.mode==="client"?g.client:g.server;this.binaryPath=d(this.workDir,"bin",this.version,s),await this.downloadFrpBinary()}hasBinary(){return f(this.binaryPath)}getConfig(){if(!f(this.configPath))return null;const t=m(this.configPath,"utf-8");return w(t)}updateConfig(t){const e={...this.getConfig()||{},...t},s=E(e);O(this.configPath,s,"utf-8")}async backupConfig(){if(!f(this.configPath))throw new u("Config file does not exist",c.CONFIG_NOT_FOUND);const t=Date.now(),e=`${this.configPath}.${t}.bak`;return await(await import("fs-extra")).copy(this.configPath,e),e}getConfigPath(){return this.configPath}readConfigFile(){return f(this.configPath)?m(this.configPath,"utf-8"):null}writeConfigFile(t){l(this.workDir),O(this.configPath,t,"utf-8")}async start(){if(await this.ensureVersion(),this.process)throw new u("Process already running",c.PROCESS_ALREADY_RUNNING);if(this.hasBinary()||await this.downloadFrpBinary(),!f(this.configPath))throw new u("Config file does not exist",c.CONFIG_NOT_FOUND);this.process=G(this.binaryPath,["-c",this.configPath],{stdio:"inherit"}),this.process.on("error",t=>{this.logger.error("FRP process error",{error:t}),this.process=null}),this.process.on("exit",t=>{t!==0&&this.logger.error("FRP process exited with non-zero code",{code:t}),this.process=null})}async stop(){if(this.process)return new Promise(t=>{this.process.on("exit",()=>{this.process=null,t()}),this.process.kill("SIGTERM"),setTimeout(()=>{this.process&&this.process.kill("SIGKILL")},5e3)})}isRunning(){return this.process!==null&&!this.process.killed}addNode(t){if(this.mode!=="client")throw new u("Nodes can only be added in client mode",c.MODE_ERROR);const e=this.getConfig()||{};e.serverAddr=t.serverAddr,e.serverPort=t.serverPort||7e3,t.token&&(e.auth={...e.auth,token:t.token}),t.config&&Object.assign(e,t.config),this.updateConfig(e)}getNode(){if(this.mode!=="client")throw new u("Nodes are only available in client mode",c.MODE_ERROR);const t=this.getConfig();return!t||!t.serverAddr?null:{id:"default",name:"default",serverAddr:t.serverAddr,serverPort:t.serverPort,token:t.auth?.token}}updateNode(t){if(this.mode!=="client")throw new u("Nodes can only be updated in client mode",c.MODE_ERROR);const e=this.getConfig()||{};t.serverAddr&&(e.serverAddr=t.serverAddr),t.serverPort&&(e.serverPort=t.serverPort),t.token&&(e.auth={...e.auth,token:t.token}),t.config&&Object.assign(e,t.config),this.updateConfig(e)}removeNode(){if(this.mode!=="client")throw new u("Nodes can only be removed in client mode",c.MODE_ERROR);f(this.configPath)&&Q(this.configPath)}addTunnel(t){if(this.mode!=="client")throw new Error("Tunnels can only be added in client mode");const e=f(this.configPath)?m(this.configPath,"utf-8"):"",s=E({[t.name]:t}),n=e?`${e}
+
+${s}`:s;O(this.configPath,n,"utf-8")}getTunnel(t){if(this.mode!=="client")throw new Error("Tunnels are only available in client mode");if(!f(this.configPath))return null;const e=m(this.configPath,"utf-8");return w(e)[t]||null}updateTunnel(t,e){if(this.mode!=="client")throw new u("Tunnels can only be updated in client mode",c.MODE_ERROR);if(!f(this.configPath))throw new u("Config file does not exist",c.CONFIG_NOT_FOUND);const s=m(this.configPath,"utf-8"),n=w(s);if(!n[t])throw new u(`Tunnel ${t} not found`,c.NOT_FOUND);n[t]={...n[t],...e};const i=E(n);O(this.configPath,i,"utf-8")}removeTunnel(t){if(this.mode!=="client")throw new u("Tunnels can only be removed in client mode",c.MODE_ERROR);if(!f(this.configPath))return;const e=m(this.configPath,"utf-8"),s=w(e);delete s[t];const n=E(s);O(this.configPath,n,"utf-8")}listTunnels(){if(this.mode!=="client")throw new u("Tunnels are only available in client mode",c.MODE_ERROR);if(!f(this.configPath))return[];const t=m(this.configPath,"utf-8"),e=w(t),s=[];for(const[n,i]of Object.entries(e))typeof i=="object"&&i!==null&&"type"in i&&s.push(i);return s}}const tt="Unknown command",et="Unknown query";class x{constructor(t,e={}){this.context=t,this.storage=e.storage,Object.entries(e.commands??{}).forEach(([s,n])=>{this.commandHandlers.set(s,n)}),Object.entries(e.queries??{}).forEach(([s,n])=>{this.queryHandlers.set(s,n)})}storage;commandHandlers=new Map;queryHandlers=new Map;eventBuffer=[];commandQueue=Promise.resolve();state={status:"idle",version:0};registerCommand(t,e){this.commandHandlers.set(t,e)}registerQuery(t,e){this.queryHandlers.set(t,e)}execute(t){const e=this.commandQueue.then(()=>this.runCommand(t));return this.commandQueue=e.then(()=>{},()=>{}),e}async query(t){const e=this.queryHandlers.get(t.name);if(!e)throw this.buildError("VALIDATION_ERROR",`${et}: ${t.name}`);return e(t,this.context)}snapshot(){return{...this.state}}drainEvents(){const t=this.eventBuffer;return this.eventBuffer=[],t}async runCommand(t){const e=this.commandHandlers.get(t.name);if(!e)return{status:"failed",error:this.buildError("VALIDATION_ERROR",`${tt}: ${t.name}`)};const s={...this.state},n={bumped:!1},i={context:this.context,state:s,emit:o=>this.pushEvents(o),requestVersionBump:()=>this.bumpVersion(t.metadata?.author,n)};this.state.status="running";try{const o=await e(t,i);return o.events&&this.pushEvents(o.events),o.snapshot&&await this.persistSnapshot(o.snapshot,t.metadata?.author),o.error?(this.state.lastError=o.error,this.state.status="error"):o.status==="success"&&(this.state.lastError=void 0,this.state.status="running"),{...o,version:o.version??this.state.version}}catch(o){const h=this.normalizeError(o);return this.state.lastError=h,this.state.status="error",{status:"failed",error:h,version:this.state.version}}}pushEvents(t){const e=this.now();t.forEach(s=>{this.eventBuffer.push({...s,timestamp:s.timestamp??e,version:s.version??this.state.version})})}bumpVersion(t,e){return e.bumped?this.state.version:(e.bumped=!0,this.state.version+=1,this.state.lastAppliedAt=this.now(),t&&this.pushEvents([{type:"config:version-bumped",timestamp:this.now(),version:this.state.version,payload:{author:t}}]),this.state.version)}async persistSnapshot(t,e){this.storage&&t&&await this.storage.save({...t,version:t.version??this.state.version,appliedAt:t.appliedAt??this.now(),author:t.author??e})}normalizeError(t){return t&&typeof t=="object"&&"code"in t&&"message"in t?t:{code:"SYSTEM_ERROR",message:t instanceof Error?t.message:"Unknown error"}}buildError(t,e,s){return{code:t,message:e,details:s}}now(){return this.context.clock?this.context.clock():Date.now()}}function B(r){return!!r&&typeof r=="object"&&"version"in r}class V{constructor(t){this.directory=t,l(t)}async save(t){if(typeof t.version!="number")throw new TypeError("Snapshot version must be a number when using FileSnapshotStorage");l(this.directory);const e=JSON.stringify(t,null,2);await K(this.buildPath(t.version),e,"utf-8")}async load(t){const e=this.buildPath(t);if(!f(e))return;const s=await S(e,"utf-8"),n=JSON.parse(s);if(!B(n))throw new TypeError(`Invalid snapshot schema at version ${t}`);return n}async list(){l(this.directory);const t=await Z(this.directory),e=[];for(const s of t){if(!s.endsWith(".json"))continue;const n=await S(d(this.directory,s),"utf-8"),i=JSON.parse(n);B(i)&&e.push(i)}return e.sort((s,n)=>s.version-n.version)}buildPath(t){return d(this.directory,`${t}.json`)}}const st="config.apply",rt="config.applyRaw",nt="process.stop",it="process.status",ot="runtime.snapshot";class at{constructor(t){this.options=t;const e=t.workDir??d(F(),".frp-bridge"),s=t.runtime?.workDir??d(e,"runtime"),n=t.process?.workDir??d(e,"process");l(e),l(s),l(n);const i=t.runtime?.logger??_.withTag("FrpRuntime"),o=t.process?.logger??_.withTag("FrpProcessManager");this.process=new M({mode:t.process?.mode??t.mode,version:t.process?.version,workDir:n,logger:o});const h=t.storage??new V(d(s,"snapshots")),a={id:t.runtime?.id??"default",mode:t.runtime?.mode??t.mode,workDir:s,platform:t.runtime?.platform??p.platform,clock:t.runtime?.clock,logger:i},y={...this.createDefaultCommands(),...t.commands??{}},v={...this.createDefaultQueries(),...t.queries??{}};this.runtime=new x(a,{storage:h,commands:y,queries:v}),this.eventSink=t.eventSink}runtime;process;eventSink;execute(t){return this.runtime.execute(t).finally(()=>{this.forwardEvents()})}query(t){return this.runtime.query(t).finally(()=>{this.forwardEvents()})}snapshot(){return this.runtime.snapshot()}drainEvents(){return this.runtime.drainEvents()}getProcessManager(){return this.process}getRuntime(){return this.runtime}createDefaultCommands(){const t=async(n,i)=>n.payload?.config?this.runConfigMutation(async()=>{this.process.updateConfig(n.payload.config)},n.payload.restart,i):{status:"failed",error:{code:"VALIDATION_ERROR",message:"config.apply requires payload.config"}},e=async(n,i)=>{const o=n.payload?.content;if(!o?.trim())return{status:"failed",error:{code:"VALIDATION_ERROR",message:"config.applyRaw requires payload.content"}};try{w(o)}catch(h){return{status:"failed",error:{code:"VALIDATION_ERROR",message:"config.applyRaw received invalid TOML content",details:h instanceof Error?{message:h.message}:void 0}}}return this.runConfigMutation(async()=>{this.process.writeConfigFile(o)},n.payload?.restart,i)},s=async()=>this.process.isRunning()?(await this.process.stop(),{status:"success",events:[{type:"process:stopped",timestamp:Date.now()}]}):{status:"success"};return{[st]:t,[rt]:e,[nt]:s}}createDefaultQueries(){const t=async()=>{const s=this.runtime.snapshot();return{result:{running:this.process.isRunning(),config:this.process.getConfig()},version:s.version}},e=async()=>{const s=this.runtime.snapshot();return{result:s,version:s.version}};return{[it]:t,[ot]:e}}forwardEvents(){this.eventSink&&this.runtime.drainEvents().forEach(t=>this.eventSink?.(t))}async runConfigMutation(t,e,s){await t();const n=e??!0;let i;return n&&(this.process.isRunning()&&await this.process.stop(),await this.process.start(),i=[{type:"process:started",timestamp:Date.now()}]),s.requestVersionBump(),{status:"success",events:i}}}export{I as ARCH_MAP,g as BINARY_NAMES,c as ErrorCode,V as FileSnapshotStorage,at as FrpBridge,u as FrpBridgeError,M as FrpProcessManager,x as FrpRuntime,P as GITHUB_OWNER,D as GITHUB_REPO,$ as OS_MAP,R as commandExists,T as downloadFile,l as ensureDir,b as executeCommand,U as getDownloadUrl,A as getLatestVersion,k as getPlatform,w as parseToml,E as toToml};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@frp-bridge/core",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Frp bridge core",
+  "license": "MIT",
+  "homepage": "https://github.com/frp-web/bridge#readme",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:frp-web/bridge.git"
+  },
+  "bugs": {
+    "url": "https://github.com/frp-web/bridge/issues"
+  },
+  "keywords": [
+    "frp",
+    "bridge",
+    "cli"
+  ],
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "axios": "^1.12.2",
+    "consola": "^3.2.3",
+    "execa": "^9.6.0",
+    "fs-extra": "^11.3.2",
+    "ini": "^5.0.0",
+    "pathe": "^2.0.3",
+    "@frp-bridge/types": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^24.7.0"
+  },
+  "scripts": {
+    "stub": "unbuild --stub",
+    "build": "unbuild"
+  }
+}