/**
 * Gateway Service
 *
 * Runs the CLI as a gateway node that polls for remote messages
 * from web/mobile clients, processes them locally with full MCP
 * tool access, and relays streaming events back through the server.
 */
import { EventEmitter } from 'events';
import { type GatewayRequest } from '../api/gateway-api.js';
export interface GatewayConfig {
    pollInterval: number;
    eventBatchInterval: number;
    requestTimeout: number;
    debug?: boolean;
    sessionName?: string;
}
export type GatewayStatus = 'idle' | 'running' | 'stopping';
export interface GatewayState {
    status: GatewayStatus;
    currentRequest?: GatewayRequest;
    completedCount: number;
    failedCount: number;
    startedAt?: Date;
    lastPollAt?: Date;
}
export type GatewayEvent = {
    type: 'started';
} | {
    type: 'stopped';
} | {
    type: 'request_claimed';
    request: GatewayRequest;
} | {
    type: 'request_completed';
    request: GatewayRequest;
    durationMs: number;
} | {
    type: 'request_failed';
    request: GatewayRequest;
    error: string;
} | {
    type: 'poll_empty';
} | {
    type: 'error';
    error: string;
} | {
    type: 'remote_content';
    text: string;
    partial: boolean;
} | {
    type: 'remote_tool_call';
    id: string;
    name: string;
    serverName?: string;
    isMcp: boolean;
} | {
    type: 'remote_tool_result';
    id: string;
    name: string;
    status: 'completed' | 'error';
} | {
    type: 'remote_done';
    conversationId?: string;
} | {
    type: 'remote_error';
    error: string;
};
export declare class GatewayService extends EventEmitter {
    private config;
    private state;
    private pollTimer;
    private heartbeatTimer;
    private abortController;
    private mcpState;
    private onMcpToolCall;
    private mcpClient;
    private sessionId?;
    private deviceName;
    private sessionName?;
    constructor(config?: Partial<GatewayConfig>);
    getState(): GatewayState;
    isProcessingRemote(): boolean;
    /**
     * Supply externally-initialized MCP state.
     * When running in unified mode, the caller initializes MCP once
     * and passes it in before calling start().
     */
    setMcpState(mcpState: unknown, onMcpToolCall: unknown, mcpClient: unknown): void;
    start(): Promise<void>;
    private registerWithCloud;
    stop(): Promise<void>;
    private startHeartbeat;
    private sendHeartbeatUpdate;
    private startPolling;
    private pollAndProcess;
    /**
     * Process a claimed gateway request by running it through the agent
     * with local MCP tools, and relay events back to the server.
     */
    private processRequest;
    private handleIncomingCommand;
    private isPathSafe;
    private static readonly HIDDEN_DIRS;
    private static readonly BINARY_EXTENSIONS;
    private static readonly MAX_FILE_READ_SIZE;
    private getFileTree;
    private getFileContent;
    private finishRequest;
    private log;
}
export declare function getGateway(config?: Partial<GatewayConfig>): GatewayService;
export declare function resetGateway(): void;
//# sourceMappingURL=service.d.ts.map