@silicaclaw/cli 2026.3.19-9 → 2026.3.20-10

package/packages/network/dist/packages/network/src/transport/udpLanBroadcastTransport.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UdpLanBroadcastTransport = void 0;
+const dgram_1 = __importDefault(require("dgram"));
+const silicaclaw_defaults_json_1 = __importDefault(require("../../../../config/silicaclaw-defaults.json"));
+class UdpLanBroadcastTransport {
+    socket = null;
+    handlers = new Set();
+    state = "stopped";
+    stats = {
+        starts: 0,
+        stops: 0,
+        start_errors: 0,
+        stop_errors: 0,
+        sent_messages: 0,
+        sent_bytes: 0,
+        send_errors: 0,
+        received_messages: 0,
+        received_bytes: 0,
+        receive_errors: 0,
+        last_sent_at: 0,
+        last_received_at: 0,
+        last_error_at: 0,
+    };
+    port;
+    bindAddress;
+    broadcastAddress;
+    constructor(options = {}) {
+        this.port = options.port ?? silicaclaw_defaults_json_1.default.ports.network_default;
+        this.bindAddress = options.bindAddress ?? "0.0.0.0";
+        this.broadcastAddress = options.broadcastAddress ?? "255.255.255.255";
+    }
+    async start() {
+        if (this.socket) {
+            return;
+        }
+        this.state = "starting";
+        this.socket = dgram_1.default.createSocket({ type: "udp4", reuseAddr: true });
+        this.socket.on("error", () => {
+            this.stats.receive_errors += 1;
+            this.stats.last_error_at = Date.now();
+            this.state = "error";
+        });
+        this.socket.on("message", (msg, rinfo) => {
+            this.stats.received_messages += 1;
+            this.stats.received_bytes += msg.length;
+            this.stats.last_received_at = Date.now();
+            const meta = {
+                remote_address: rinfo.address,
+                remote_port: rinfo.port,
+                transport: "udp-lan-broadcast",
+            };
+            for (const handler of this.handlers) {
+                try {
+                    handler(msg, meta);
+                }
+                catch {
+                    this.stats.receive_errors += 1;
+                    this.stats.last_error_at = Date.now();
+                }
+            }
+        });
+        await new Promise((resolve, reject) => {
+            if (!this.socket) {
+                this.state = "error";
+                reject(new Error("Transport socket unavailable"));
+                return;
+            }
+            this.socket.once("error", reject);
+            this.socket.bind(this.port, this.bindAddress, () => {
+                if (!this.socket) {
+                    this.state = "error";
+                    reject(new Error("Transport socket unavailable after bind"));
+                    return;
+                }
+                this.socket.setBroadcast(true);
+                this.socket.off("error", reject);
+                this.stats.starts += 1;
+                this.state = "running";
+                resolve();
+            });
+        }).catch((error) => {
+            this.stats.start_errors += 1;
+            this.stats.last_error_at = Date.now();
+            this.state = "error";
+            this.socket = null;
+            throw error;
+        });
+    }
+    async stop() {
+        if (!this.socket) {
+            return;
+        }
+        this.state = "stopping";
+        const socket = this.socket;
+        this.socket = null;
+        await new Promise((resolve) => {
+            socket.close(() => resolve());
+        }).then(() => {
+            this.stats.stops += 1;
+            this.state = "stopped";
+        }).catch((error) => {
+            this.stats.stop_errors += 1;
+            this.stats.last_error_at = Date.now();
+            this.state = "error";
+            throw error;
+        });
+    }
+    async send(data) {
+        if (!this.socket) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            if (!this.socket) {
+                resolve();
+                return;
+            }
+            this.socket.send(data, this.port, this.broadcastAddress, (error) => {
+                if (error) {
+                    this.stats.send_errors += 1;
+                    this.stats.last_error_at = Date.now();
+                    reject(error);
+                    return;
+                }
+                this.stats.sent_messages += 1;
+                this.stats.sent_bytes += data.length;
+                this.stats.last_sent_at = Date.now();
+                resolve();
+            });
+        });
+    }
+    onMessage(handler) {
+        this.handlers.add(handler);
+        return () => {
+            this.handlers.delete(handler);
+        };
+    }
+    getStats() {
+        return { ...this.stats };
+    }
+    getConfig() {
+        return {
+            transport: "udp-lan-broadcast",
+            state: this.state,
+            bind_address: this.bindAddress,
+            broadcast_address: this.broadcastAddress,
+            port: this.port,
+        };
+    }
+}
+exports.UdpLanBroadcastTransport = UdpLanBroadcastTransport;

package/packages/network/dist/packages/network/src/types.d.ts

@@ -0,0 +1,10 @@
+export interface NetworkAdapter {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    publish(topic: string, data: any): Promise<void>;
+    subscribe(topic: string, handler: (data: any) => void): void;
+    sendDirect?(peerId: string, topic: string, data: any): Promise<void>;
+    subscribeDirect?(topic: string, handler: (data: any, meta?: {
+        peerId?: string;
+    }) => void): void;
+}

package/packages/network/dist/packages/network/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/network/dist/packages/network/src/webrtcPreview.d.ts

@@ -0,0 +1,163 @@
+import { NetworkAdapter } from "./types";
+type WebRTCPreviewOptions = {
+    peerId?: string;
+    namespace?: string;
+    signalingUrl?: string;
+    signalingUrls?: string[];
+    room?: string;
+    seedPeers?: string[];
+    bootstrapHints?: string[];
+    bootstrapSources?: string[];
+    maxMessageBytes?: number;
+    pollIntervalMs?: number;
+    maxFutureDriftMs?: number;
+    maxPastDriftMs?: number;
+    discoveryEventsLimit?: number;
+};
+type PeerStatus = "connecting" | "online" | "stale";
+type WebRTCConnectionState = "new" | "connecting" | "connected" | "disconnected" | "failed" | "closed" | "unknown";
+type WebRTCDataChannelState = "connecting" | "open" | "closing" | "closed" | "unknown";
+type StateSummary<T extends string> = Record<T, number>;
+type WebRTCDiagnostics = {
+    adapter: "webrtc-preview";
+    peer_id: string;
+    namespace: string;
+    room: string;
+    signaling_url: string;
+    signaling_endpoints: string[];
+    bootstrap_sources: string[];
+    seed_peers_count: number;
+    bootstrap_hints_count: number;
+    discovery_events_total: number;
+    last_discovery_event_at: number;
+    discovery_events: DiscoveryEvent[];
+    connection_states_summary: StateSummary<WebRTCConnectionState>;
+    datachannel_states_summary: StateSummary<WebRTCDataChannelState>;
+    signaling_messages_sent_total: number;
+    signaling_messages_received_total: number;
+    reconnect_attempts_total: number;
+    active_webrtc_peers: number;
+    components: {
+        transport: string;
+        discovery: string;
+        envelope_codec: string;
+        topic_codec: string;
+    };
+    limits: {
+        max_message_bytes: number;
+        max_future_drift_ms: number;
+        max_past_drift_ms: number;
+    };
+    config: {
+        started: boolean;
+        topic_handler_count: number;
+        poll_interval_ms: number;
+    };
+    peers: {
+        total: number;
+        online: number;
+        stale: number;
+        items: Array<{
+            peer_id: string;
+            status: PeerStatus;
+            first_seen_at: number;
+            last_seen_at: number;
+            messages_seen: number;
+            reconnect_attempts: number;
+            connection_state: WebRTCConnectionState;
+            datachannel_state: WebRTCDataChannelState;
+        }>;
+    };
+    stats: {
+        publish_attempted: number;
+        publish_sent: number;
+        received_total: number;
+        delivered_total: number;
+        dropped_malformed: number;
+        dropped_oversized: number;
+        dropped_namespace_mismatch: number;
+        dropped_timestamp_future_drift: number;
+        dropped_timestamp_past_drift: number;
+        dropped_decode_failed: number;
+        dropped_self: number;
+        dropped_topic_decode_error: number;
+        dropped_handler_error: number;
+        signaling_errors: number;
+        invalid_signaling_payload_total: number;
+        duplicate_sdp_total: number;
+        duplicate_ice_total: number;
+        start_errors: number;
+        stop_errors: number;
+        received_validated: number;
+    };
+};
+type DiscoveryEventType = "peer_joined" | "peer_stale" | "peer_removed" | "signaling_connected" | "signaling_disconnected" | "reconnect_started" | "reconnect_succeeded" | "reconnect_failed" | "malformed_signal_dropped" | "duplicate_signal_dropped";
+type DiscoveryEvent = {
+    id: string;
+    type: DiscoveryEventType;
+    at: number;
+    peer_id?: string;
+    endpoint?: string;
+    detail?: string;
+};
+export declare class WebRTCPreviewAdapter implements NetworkAdapter {
+    private readonly peerId;
+    private readonly namespace;
+    private readonly signalingUrl;
+    private readonly signalingEndpoints;
+    private readonly room;
+    private readonly seedPeers;
+    private readonly bootstrapHints;
+    private readonly bootstrapSources;
+    private readonly maxMessageBytes;
+    private readonly pollIntervalMs;
+    private readonly maxFutureDriftMs;
+    private readonly maxPastDriftMs;
+    private readonly discoveryEventsLimit;
+    private readonly envelopeCodec;
+    private readonly topicCodec;
+    private readonly handlers;
+    private readonly sessions;
+    private started;
+    private poller;
+    private wrtc;
+    private processedSignalIds;
+    private signalingConnectivity;
+    private signalingIndex;
+    private activeSignalingEndpoint;
+    private discoveryEvents;
+    private discoveryEventsTotal;
+    private lastDiscoveryEventAt;
+    private signalingMessagesSentTotal;
+    private signalingMessagesReceivedTotal;
+    private reconnectAttemptsTotal;
+    private stats;
+    constructor(options?: WebRTCPreviewOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    publish(topic: string, data: any): Promise<void>;
+    subscribe(topic: string, handler: (data: any) => void): void;
+    getDiagnostics(): WebRTCDiagnostics;
+    private resolveWebRTCImplementation;
+    private pollOnce;
+    private syncPeersFromSignaling;
+    private ensureSession;
+    private shouldAttemptConnect;
+    private attemptReconnect;
+    private createPeerConnection;
+    private bindDataChannel;
+    private handleSignalMessage;
+    private flushBufferedIce;
+    private onDataMessage;
+    private cleanupProcessedSignalIds;
+    private isInitiatorFor;
+    private closePeerSession;
+    private sendSignal;
+    private postJson;
+    private getJson;
+    private requestJson;
+    private markSignalingConnected;
+    private markSignalingDisconnected;
+    private recordDiscoveryEvent;
+}
+export {};