@shepai/cli 1.180.0 → 1.181.0-pr512.ba01d33

package/dist/packages/core/src/infrastructure/services/messaging/command-executor.js

@@ -0,0 +1,200 @@
+/**
+ * Messaging Command Executor
+ *
+ * Maps inbound MessagingCommand payloads from the Gateway tunnel
+ * to existing Shep use case invocations. This is the bridge between
+ * external messaging commands and the application layer.
+ *
+ * All commands are mapped to existing use cases — no new business logic
+ * is introduced here. The executor is a thin translation layer.
+ *
+ * Feature ID resolution: messaging commands use short IDs (first 8 chars
+ * of the UUID). The ShowFeatureUseCase and ResumeFeatureUseCase support
+ * prefix matching via findByIdPrefix. For approve/reject/stop, we resolve
+ * the feature first, then use its agentRunId.
+ */
+const HELP_TEXT = `Available commands:
+/new <description> — Create a new feature
+/approve <id> — Approve gate on feature
+/reject <id> [feedback] — Reject with feedback
+/stop <id> — Stop agent on feature
+/resume <id> — Resume paused feature
+/status — List all active features
+/status <id> — Show detail for feature
+/help — Show this help text`;
+/** Format a feature for display in messaging */
+function formatFeature(f) {
+    const shortId = f.id.slice(0, 8);
+    return `#${shortId} "${f.name}" — ${f.lifecycle}`;
+}
+/**
+ * Execute messaging commands by delegating to existing use cases.
+ */
+export class MessagingCommandExecutor {
+    featureRepo;
+    createFeature;
+    approveAgentRun;
+    rejectAgentRun;
+    stopAgentRun;
+    resumeFeature;
+    listFeatures;
+    showFeature;
+    listRepositories;
+    constructor(featureRepo, createFeature, approveAgentRun, rejectAgentRun, stopAgentRun, resumeFeature, listFeatures, showFeature, listRepositories) {
+        this.featureRepo = featureRepo;
+        this.createFeature = createFeature;
+        this.approveAgentRun = approveAgentRun;
+        this.rejectAgentRun = rejectAgentRun;
+        this.stopAgentRun = stopAgentRun;
+        this.resumeFeature = resumeFeature;
+        this.listFeatures = listFeatures;
+        this.showFeature = showFeature;
+        this.listRepositories = listRepositories;
+    }
+    /**
+     * Execute a messaging command and return a human-readable response.
+     */
+    async execute(cmd) {
+        switch (cmd.command) {
+            case 'new':
+                return this.handleNew(cmd);
+            case 'approve':
+                return this.handleApprove(cmd);
+            case 'reject':
+                return this.handleReject(cmd);
+            case 'stop':
+                return this.handleStop(cmd);
+            case 'resume':
+                return this.handleResume(cmd);
+            case 'status':
+                return this.handleStatus(cmd);
+            case 'help':
+                return HELP_TEXT;
+            default:
+                return `Unknown command: ${cmd.command}. Send /help for available commands.`;
+        }
+    }
+    async handleNew(cmd) {
+        if (!cmd.args) {
+            return 'Usage: /new <feature description>';
+        }
+        try {
+            // Resolve a default repository path from the first tracked repository
+            const repos = await this.listRepositories.execute();
+            if (repos.length === 0) {
+                return 'No repositories configured. Add a repository in the Shep UI first.';
+            }
+            const result = await this.createFeature.execute({
+                userInput: cmd.args,
+                repositoryPath: repos[0].path,
+                fast: true,
+                push: true,
+                openPr: true,
+            });
+            const shortId = result.feature.id.slice(0, 8);
+            return `Started: "${cmd.args}" — feature #${shortId}`;
+        }
+        catch (error) {
+            return `Failed to create feature: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleApprove(cmd) {
+        if (!cmd.featureId) {
+            return 'Usage: /approve <feature_id>';
+        }
+        try {
+            const feature = await this.resolveFeature(cmd.featureId);
+            if (!feature) {
+                return `Feature #${cmd.featureId} not found`;
+            }
+            if (!feature.agentRunId) {
+                return `Feature #${cmd.featureId} has no active agent run`;
+            }
+            const result = await this.approveAgentRun.execute(feature.agentRunId);
+            if (!result.approved) {
+                return `Cannot approve: ${result.reason}`;
+            }
+            return `Approved feature #${cmd.featureId}`;
+        }
+        catch (error) {
+            return `Failed to approve: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleReject(cmd) {
+        if (!cmd.featureId) {
+            return 'Usage: /reject <feature_id> [feedback]';
+        }
+        try {
+            const feature = await this.resolveFeature(cmd.featureId);
+            if (!feature) {
+                return `Feature #${cmd.featureId} not found`;
+            }
+            if (!feature.agentRunId) {
+                return `Feature #${cmd.featureId} has no active agent run`;
+            }
+            const result = await this.rejectAgentRun.execute(feature.agentRunId, cmd.args ?? 'Rejected via messaging');
+            if (!result.rejected) {
+                return `Cannot reject: ${result.reason}`;
+            }
+            return `Rejected feature #${cmd.featureId}${cmd.args ? ' with feedback' : ''}`;
+        }
+        catch (error) {
+            return `Failed to reject: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleStop(cmd) {
+        if (!cmd.featureId) {
+            return 'Usage: /stop <feature_id>';
+        }
+        try {
+            const feature = await this.resolveFeature(cmd.featureId);
+            if (!feature) {
+                return `Feature #${cmd.featureId} not found`;
+            }
+            if (!feature.agentRunId) {
+                return `Feature #${cmd.featureId} has no active agent run`;
+            }
+            const result = await this.stopAgentRun.execute(feature.agentRunId);
+            if (!result.stopped) {
+                return `Cannot stop: ${result.reason}`;
+            }
+            return `Stopped agent on feature #${cmd.featureId}`;
+        }
+        catch (error) {
+            return `Failed to stop: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleResume(cmd) {
+        if (!cmd.featureId) {
+            return 'Usage: /resume <feature_id>';
+        }
+        try {
+            await this.resumeFeature.execute(cmd.featureId);
+            return `Resumed feature #${cmd.featureId}`;
+        }
+        catch (error) {
+            return `Failed to resume: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleStatus(cmd) {
+        try {
+            if (cmd.featureId) {
+                const feature = await this.showFeature.execute(cmd.featureId);
+                return formatFeature(feature);
+            }
+            const features = await this.listFeatures.execute();
+            if (features.length === 0) {
+                return 'No active features.';
+            }
+            return features.map(formatFeature).join('\n');
+        }
+        catch (error) {
+            return `Failed to get status: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /** Resolve a feature by exact ID or prefix match */
+    async resolveFeature(featureId) {
+        return ((await this.featureRepo.findById(featureId)) ??
+            (await this.featureRepo.findByIdPrefix(featureId)));
+    }
+}

package/dist/packages/core/src/infrastructure/services/messaging/content-sanitizer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Content Sanitizer
+ *
+ * Sanitizes outbound messages to ensure no sensitive content
+ * (file paths, environment variables, code blocks, secrets)
+ * is transmitted through third-party messaging platforms.
+ *
+ * Security requirement FR-6: no source code, diffs, or file
+ * contents transmitted through messaging platforms.
+ */
+/**
+ * Strip sensitive content from a message before sending to a messaging platform.
+ *
+ * Removes:
+ * - Absolute file paths
+ * - Environment variable assignments
+ * - Code blocks (fenced with backticks)
+ * - Potential secret patterns (API keys, tokens)
+ *
+ * Truncates to messaging-safe length.
+ */
+export declare function sanitizeForMessaging(text: string): string;
+//# sourceMappingURL=content-sanitizer.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/content-sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-sanitizer.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/content-sanitizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsBzD"}

package/dist/packages/core/src/infrastructure/services/messaging/content-sanitizer.js

@@ -0,0 +1,39 @@
+/**
+ * Content Sanitizer
+ *
+ * Sanitizes outbound messages to ensure no sensitive content
+ * (file paths, environment variables, code blocks, secrets)
+ * is transmitted through third-party messaging platforms.
+ *
+ * Security requirement FR-6: no source code, diffs, or file
+ * contents transmitted through messaging platforms.
+ */
+const MAX_MESSAGE_LENGTH = 4000;
+/**
+ * Strip sensitive content from a message before sending to a messaging platform.
+ *
+ * Removes:
+ * - Absolute file paths
+ * - Environment variable assignments
+ * - Code blocks (fenced with backticks)
+ * - Potential secret patterns (API keys, tokens)
+ *
+ * Truncates to messaging-safe length.
+ */
+export function sanitizeForMessaging(text) {
+    let sanitized = text;
+    // Strip absolute file paths (Unix and Windows)
+    sanitized = sanitized.replace(/(?:\/[\w.\-/]+){2,}/g, '[path]');
+    sanitized = sanitized.replace(/[A-Z]:\\[\w.\-\\]+/g, '[path]');
+    // Strip env-var-like patterns (KEY=value)
+    sanitized = sanitized.replace(/[A-Z_]{3,}=\S+/g, '[env]');
+    // Strip fenced code blocks
+    sanitized = sanitized.replace(/```[\s\S]*?```/g, '[code block]');
+    // Strip inline code that looks like file content
+    sanitized = sanitized.replace(/`[^`]{100,}`/g, '[code]');
+    // Truncate to messaging-safe length
+    if (sanitized.length > MAX_MESSAGE_LENGTH) {
+        sanitized = `${sanitized.slice(0, MAX_MESSAGE_LENGTH - 3)}...`;
+    }
+    return sanitized;
+}

package/dist/packages/core/src/infrastructure/services/messaging/http-gateway.client.d.ts

@@ -0,0 +1,19 @@
+/**
+ * HTTP Gateway Client
+ *
+ * Concrete implementation of IGatewayClient that speaks the Commands.com
+ * Gateway OpenAPI (see https://github.com/Commands-com/gateway/blob/main/docs/openapi.yaml).
+ *
+ * This adapter is infrastructure — it knows about HTTP verbs, status codes,
+ * and the gateway's wire format. Callers receive domain objects only.
+ */
+import type { IGatewayClient, FetchTokenInput, GatewayOAuthToken, CreateIntegrationRouteInput, GatewayIntegrationRoute } from '../../../application/ports/output/services/gateway-client.interface.js';
+type FetchFn = typeof fetch;
+export declare class HttpGatewayClient implements IGatewayClient {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: FetchFn);
+    fetchAccessToken(input: FetchTokenInput): Promise<GatewayOAuthToken>;
+    createIntegrationRoute(gatewayUrl: string, accessToken: string, input: CreateIntegrationRouteInput): Promise<GatewayIntegrationRoute>;
+}
+export {};
+//# sourceMappingURL=http-gateway.client.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/http-gateway.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-gateway.client.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/http-gateway.client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,2BAA2B,EAC3B,uBAAuB,EACxB,MAAM,wEAAwE,CAAC;AAEhF,KAAK,OAAO,GAAG,OAAO,KAAK,CAAC;AAqB5B,qBACa,iBAAkB,YAAW,cAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,GAAE,OAAe;IAEjD,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA+CpE,sBAAsB,CAC1B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,uBAAuB,CAAC;CAsDpC"}

package/dist/packages/core/src/infrastructure/services/messaging/http-gateway.client.js

@@ -0,0 +1,124 @@
+/**
+ * HTTP Gateway Client
+ *
+ * Concrete implementation of IGatewayClient that speaks the Commands.com
+ * Gateway OpenAPI (see https://github.com/Commands-com/gateway/blob/main/docs/openapi.yaml).
+ *
+ * This adapter is infrastructure — it knows about HTTP verbs, status codes,
+ * and the gateway's wire format. Callers receive domain objects only.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { injectable } from 'tsyringe';
+function stripTrailingSlash(url) {
+    return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+async function readErrorBody(response) {
+    try {
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            const json = (await response.json());
+            const err = typeof json.error === 'string' ? json.error : undefined;
+            const msg = typeof json.message === 'string' ? json.message : undefined;
+            return err ?? msg ?? JSON.stringify(json);
+        }
+        return await response.text();
+    }
+    catch {
+        return '';
+    }
+}
+let HttpGatewayClient = class HttpGatewayClient {
+    fetchImpl;
+    constructor(fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+    }
+    async fetchAccessToken(input) {
+        const base = stripTrailingSlash(input.gatewayUrl);
+        const url = `${base}/oauth/token`;
+        const params = new URLSearchParams();
+        params.set('grant_type', 'client_credentials');
+        params.set('client_id', input.clientId);
+        if (input.clientSecret) {
+            params.set('client_secret', input.clientSecret);
+        }
+        if (input.scope) {
+            params.set('scope', input.scope);
+        }
+        const response = await this.fetchImpl(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            const detail = await readErrorBody(response);
+            throw new Error(`Gateway /oauth/token failed with ${response.status}${detail ? `: ${detail}` : ''}`);
+        }
+        const body = (await response.json());
+        if (!body.access_token) {
+            throw new Error('Gateway /oauth/token response missing access_token');
+        }
+        const expiresInMs = Math.max(0, (body.expires_in ?? 0) * 1000);
+        return {
+            accessToken: body.access_token,
+            tokenType: body.token_type ?? 'Bearer',
+            expiresAt: Date.now() + expiresInMs,
+            refreshToken: body.refresh_token,
+        };
+    }
+    async createIntegrationRoute(gatewayUrl, accessToken, input) {
+        const base = stripTrailingSlash(gatewayUrl);
+        const url = `${base}/gateway/v1/integrations/routes`;
+        const payload = {
+            device_id: input.deviceId,
+            interface_type: input.interfaceType,
+            token_auth_mode: 'path',
+        };
+        if (input.routeToken !== undefined)
+            payload.route_token = input.routeToken;
+        if (input.tokenMaxAgeDays !== undefined)
+            payload.token_max_age_days = input.tokenMaxAgeDays;
+        if (input.maxBodyBytes !== undefined)
+            payload.max_body_bytes = input.maxBodyBytes;
+        if (input.deadlineMs !== undefined)
+            payload.deadline_ms = input.deadlineMs;
+        const response = await this.fetchImpl(url, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${accessToken}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const detail = await readErrorBody(response);
+            throw new Error(`Gateway /gateway/v1/integrations/routes failed with ${response.status}${detail ? `: ${detail}` : ''}`);
+        }
+        const body = (await response.json());
+        const routeId = body.route?.route_id;
+        const publicUrl = body.public_url;
+        const routeToken = body.route_token;
+        if (!routeId || !publicUrl || !routeToken) {
+            throw new Error('Gateway route response missing route_id, public_url, or route_token');
+        }
+        return {
+            routeId,
+            routeToken,
+            publicUrl,
+            deviceId: body.route?.device_id ?? input.deviceId,
+            interfaceType: body.route?.interface_type ?? input.interfaceType,
+        };
+    }
+};
+HttpGatewayClient = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Function])
+], HttpGatewayClient);
+export { HttpGatewayClient };

package/dist/packages/core/src/infrastructure/services/messaging/http-telegram.client.d.ts

@@ -0,0 +1,18 @@
+/**
+ * HTTP Telegram Client
+ *
+ * Thin adapter over the Telegram Bot API for sending messages. Only
+ * implements the surface needed for the remote control integration —
+ * sendMessage, with optional parse_mode.
+ *
+ * Reference: https://core.telegram.org/bots/api#sendmessage
+ */
+import type { ITelegramClient, SendTelegramMessageInput } from '../../../application/ports/output/services/telegram-client.interface.js';
+type FetchFn = typeof fetch;
+export declare class HttpTelegramClient implements ITelegramClient {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: FetchFn);
+    sendMessage(input: SendTelegramMessageInput): Promise<void>;
+}
+export {};
+//# sourceMappingURL=http-telegram.client.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/http-telegram.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-telegram.client.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/http-telegram.client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,wBAAwB,EACzB,MAAM,yEAAyE,CAAC;AAEjF,KAAK,OAAO,GAAG,OAAO,KAAK,CAAC;AAI5B,qBACa,kBAAmB,YAAW,eAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,GAAE,OAAe;IAEjD,WAAW,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;CA8BlE"}

package/dist/packages/core/src/infrastructure/services/messaging/http-telegram.client.js

@@ -0,0 +1,60 @@
+/**
+ * HTTP Telegram Client
+ *
+ * Thin adapter over the Telegram Bot API for sending messages. Only
+ * implements the surface needed for the remote control integration —
+ * sendMessage, with optional parse_mode.
+ *
+ * Reference: https://core.telegram.org/bots/api#sendmessage
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { injectable } from 'tsyringe';
+const TELEGRAM_API_BASE = 'https://api.telegram.org';
+let HttpTelegramClient = class HttpTelegramClient {
+    fetchImpl;
+    constructor(fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+    }
+    async sendMessage(input) {
+        if (!input.botToken)
+            throw new Error('Telegram botToken is required');
+        if (!input.chatId)
+            throw new Error('Telegram chatId is required');
+        const url = `${TELEGRAM_API_BASE}/bot${input.botToken}/sendMessage`;
+        const body = {
+            chat_id: input.chatId,
+            text: input.text,
+        };
+        if (input.parseMode)
+            body.parse_mode = input.parseMode;
+        const response = await this.fetchImpl(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            let detail = '';
+            try {
+                const json = (await response.json());
+                detail = json.description ?? '';
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(`Telegram sendMessage failed with ${response.status}${detail ? `: ${detail}` : ''}`);
+        }
+    }
+};
+HttpTelegramClient = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Function])
+], HttpTelegramClient);
+export { HttpTelegramClient };

package/dist/packages/core/src/infrastructure/services/messaging/messaging-tunnel.adapter.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Messaging Tunnel Adapter
+ *
+ * Manages the WebSocket tunnel connection to the Commands.com Gateway and
+ * translates its binary/text frames into a presentation-agnostic callback
+ * for the consuming messaging service.
+ *
+ * Protocol reference:
+ *   https://github.com/Commands-com/gateway/blob/main/internal/gateway/integrations_tunnel.go
+ *
+ * Responsibilities:
+ *   - Open an authenticated WebSocket (Bearer token on the upgrade headers)
+ *   - Handle tunnel.connected → auto-activate the configured routes
+ *   - Decode incoming tunnel.request frames and dispatch to `onRequest`
+ *   - Send tunnel.response frames back with the handler's reply
+ *   - Reconnect on disconnect with a small delay
+ */
+import WebSocket, { type ClientOptions } from 'ws';
+import type { DecodedTunnelRequest, TunnelRequestResponse } from './tunnel-protocol.js';
+export type TunnelRequestHandler = (request: DecodedTunnelRequest) => Promise<TunnelRequestResponse>;
+/** Factory allowing tests to substitute an in-memory transport. */
+export type WebSocketFactory = (url: string, options: ClientOptions) => WebSocket;
+export interface MessagingTunnelAdapterDeps {
+    gatewayUrl: string;
+    accessToken: string;
+    deviceId: string;
+    /** Route IDs to claim after tunnel.connected arrives. */
+    routeIds: string[];
+    webSocketFactory?: WebSocketFactory;
+}
+export declare class MessagingTunnelAdapter {
+    private readonly deps;
+    private ws;
+    private requestHandler;
+    private pingTimer;
+    private reconnectTimer;
+    private connected;
+    private stopping;
+    private readonly activatedRoutes;
+    private readonly factory;
+    constructor(deps: MessagingTunnelAdapterDeps);
+    /** Register a handler for inbound tunnel.request frames. */
+    onRequest(handler: TunnelRequestHandler): void;
+    /** Whether the WebSocket tunnel is currently open. */
+    isConnected(): boolean;
+    /** Whether the given route has been activated on the tunnel. */
+    isRouteActivated(routeId: string): boolean;
+    /**
+     * Open the tunnel and resolve once the server has emitted tunnel.connected.
+     * Reconnects are silent (fire-and-forget).
+     */
+    connect(): Promise<void>;
+    /** Close the tunnel permanently (no auto-reconnect). */
+    disconnect(): Promise<void>;
+    private handleRawFrame;
+    private handleConnected;
+    private handleActivateResult;
+    private handleRouteDeactivated;
+    private handleProtocolError;
+    private handleRequest;
+    private sendFrame;
+    private handleClose;
+    private startPing;
+    private stopPing;
+    private scheduleReconnect;
+    private clearReconnect;
+}
+//# sourceMappingURL=messaging-tunnel.adapter.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/messaging-tunnel.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messaging-tunnel.adapter.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/messaging-tunnel.adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,SAAS,EAAE,EAAE,KAAK,aAAa,EAAgB,MAAM,IAAI,CAAC;AACjE,OAAO,KAAK,EACV,oBAAoB,EAOpB,qBAAqB,EAGtB,MAAM,sBAAsB,CAAC;AAK9B,MAAM,MAAM,oBAAoB,GAAG,CACjC,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAEpC,mEAAmE;AACnE,MAAM,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,KAAK,SAAS,CAAC;AAIlF,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAwBD,qBAAa,sBAAsB;IAUrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IATjC,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqB;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;gBAEd,IAAI,EAAE,0BAA0B;IAI7D,4DAA4D;IAC5D,SAAS,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAI9C,sDAAsD;IACtD,WAAW,IAAI,OAAO;IAItB,gEAAgE;IAChE,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI1C;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC9B,wDAAwD;IAClD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAiBnB,cAAc;IA+B5B,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,mBAAmB;YAIb,aAAa;IAmC3B,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,SAAS;IAajB,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,cAAc;CAMvB"}