@silicaclaw/cli 2026.3.19-2 → 2026.3.19-21

package/node_modules/@silicaclaw/network/dist/relayPreview.js

@@ -0,0 +1,442 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelayPreviewAdapter = void 0;
+const crypto_1 = require("crypto");
+const messageEnvelope_1 = require("./abstractions/messageEnvelope");
+const jsonMessageEnvelopeCodec_1 = require("./codec/jsonMessageEnvelopeCodec");
+const jsonTopicCodec_1 = require("./codec/jsonTopicCodec");
+function dedupe(values) {
+    return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+class RelayPreviewAdapter {
+    peerId;
+    namespace;
+    signalingEndpoints;
+    room;
+    seedPeers;
+    bootstrapHints;
+    bootstrapSources;
+    maxMessageBytes;
+    pollIntervalMs;
+    maxFutureDriftMs;
+    maxPastDriftMs;
+    requestTimeoutMs;
+    peerRefreshIntervalMs;
+    envelopeCodec;
+    topicCodec;
+    started = false;
+    poller = null;
+    handlers = new Map();
+    peers = new Map();
+    seenMessageIds = new Set();
+    activeEndpoint = "";
+    discoveryEvents = [];
+    discoveryEventsTotal = 0;
+    lastDiscoveryEventAt = 0;
+    signalingMessagesSentTotal = 0;
+    signalingMessagesReceivedTotal = 0;
+    reconnectAttemptsTotal = 0;
+    activeEndpointIndex = 0;
+    lastJoinAt = 0;
+    lastPollAt = 0;
+    lastPublishAt = 0;
+    lastPeerRefreshAt = 0;
+    lastErrorAt = 0;
+    lastError = null;
+    pollInFlight = false;
+    currentPollDelayMs = 0;
+    stats = {
+        publish_attempted: 0,
+        publish_sent: 0,
+        received_total: 0,
+        delivered_total: 0,
+        dropped_malformed: 0,
+        dropped_oversized: 0,
+        dropped_namespace_mismatch: 0,
+        dropped_timestamp_future_drift: 0,
+        dropped_timestamp_past_drift: 0,
+        dropped_decode_failed: 0,
+        dropped_self: 0,
+        dropped_topic_decode_error: 0,
+        dropped_handler_error: 0,
+        signaling_errors: 0,
+        invalid_signaling_payload_total: 0,
+        duplicate_sdp_total: 0,
+        duplicate_ice_total: 0,
+        start_errors: 0,
+        stop_errors: 0,
+        received_validated: 0,
+        join_attempted: 0,
+        join_succeeded: 0,
+        poll_attempted: 0,
+        poll_succeeded: 0,
+        peers_refresh_attempted: 0,
+        peers_refresh_succeeded: 0,
+        publish_succeeded: 0,
+        poll_skipped_inflight: 0,
+    };
+    constructor(options = {}) {
+        this.peerId = options.peerId ?? `peer-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+        this.namespace = String(options.namespace || "silicaclaw.preview").trim() || "silicaclaw.preview";
+        this.signalingEndpoints = dedupe((options.signalingUrls && options.signalingUrls.length > 0
+            ? options.signalingUrls
+            : [options.signalingUrl || "http://localhost:4510"]));
+        this.activeEndpoint = this.signalingEndpoints[0] || "http://localhost:4510";
+        this.activeEndpointIndex = 0;
+        this.room = String(options.room || "silicaclaw-global-preview").trim() || "silicaclaw-global-preview";
+        this.seedPeers = dedupe(options.seedPeers || []);
+        this.bootstrapHints = dedupe(options.bootstrapHints || []);
+        this.bootstrapSources = dedupe(options.bootstrapSources || []);
+        this.maxMessageBytes = options.maxMessageBytes ?? 64 * 1024;
+        this.pollIntervalMs = options.pollIntervalMs ?? 5000;
+        this.maxFutureDriftMs = options.maxFutureDriftMs ?? 30_000;
+        this.maxPastDriftMs = options.maxPastDriftMs ?? 120_000;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? 4000;
+        this.peerRefreshIntervalMs = options.peerRefreshIntervalMs ?? 30_000;
+        this.envelopeCodec = new jsonMessageEnvelopeCodec_1.JsonMessageEnvelopeCodec();
+        this.topicCodec = new jsonTopicCodec_1.JsonTopicCodec();
+        this.currentPollDelayMs = this.pollIntervalMs;
+    }
+    async start() {
+        if (this.started)
+            return;
+        try {
+            await this.joinRoom("start");
+            this.started = true;
+            await this.refreshPeers();
+            await this.pollOnce();
+            this.scheduleNextPoll(this.pollIntervalMs);
+            this.recordDiscovery("signaling_connected", { endpoint: this.activeEndpoint });
+        }
+        catch (error) {
+            this.stats.start_errors += 1;
+            throw new Error(`Relay start failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async stop() {
+        if (!this.started)
+            return;
+        if (this.poller) {
+            clearTimeout(this.poller);
+            this.poller = null;
+        }
+        try {
+            await this.post("/leave", { room: this.room, peer_id: this.peerId });
+        }
+        catch {
+            this.stats.stop_errors += 1;
+        }
+        this.started = false;
+        this.recordDiscovery("signaling_disconnected", { endpoint: this.activeEndpoint });
+    }
+    async publish(topic, data) {
+        if (!this.started)
+            return;
+        this.stats.publish_attempted += 1;
+        await this.maybeRefreshJoin("publish");
+        const envelope = {
+            version: 1,
+            message_id: (0, crypto_1.randomUUID)(),
+            topic: `${this.namespace}:${topic}`,
+            source_peer_id: this.peerId,
+            timestamp: Date.now(),
+            payload: this.topicCodec.encode(topic, data),
+        };
+        const raw = this.envelopeCodec.encode(envelope);
+        if (raw.length > this.maxMessageBytes) {
+            this.stats.dropped_oversized += 1;
+            return;
+        }
+        await this.post("/relay/publish", { room: this.room, peer_id: this.peerId, envelope });
+        this.lastPublishAt = Date.now();
+        this.stats.publish_sent += 1;
+        this.stats.publish_succeeded += 1;
+        this.signalingMessagesSentTotal += 1;
+    }
+    subscribe(topic, handler) {
+        const key = `${this.namespace}:${topic}`;
+        if (!this.handlers.has(key)) {
+            this.handlers.set(key, new Set());
+        }
+        this.handlers.get(key)?.add(handler);
+    }
+    getDiagnostics() {
+        const peerItems = Array.from(this.peers.values()).sort((a, b) => b.last_seen_at - a.last_seen_at);
+        return {
+            adapter: "relay-preview",
+            peer_id: this.peerId,
+            namespace: this.namespace,
+            room: this.room,
+            signaling_url: this.activeEndpoint,
+            signaling_endpoints: this.signalingEndpoints,
+            active_endpoint_index: this.activeEndpointIndex,
+            bootstrap_sources: this.bootstrapSources,
+            seed_peers_count: this.seedPeers.length,
+            bootstrap_hints_count: this.bootstrapHints.length,
+            discovery_events_total: this.discoveryEventsTotal,
+            last_discovery_event_at: this.lastDiscoveryEventAt,
+            last_join_at: this.lastJoinAt,
+            last_poll_at: this.lastPollAt,
+            last_publish_at: this.lastPublishAt,
+            last_peer_refresh_at: this.lastPeerRefreshAt,
+            last_error_at: this.lastErrorAt,
+            last_error: this.lastError,
+            discovery_events: this.discoveryEvents,
+            signaling_messages_sent_total: this.signalingMessagesSentTotal,
+            signaling_messages_received_total: this.signalingMessagesReceivedTotal,
+            reconnect_attempts_total: this.reconnectAttemptsTotal,
+            active_webrtc_peers: peerItems.length,
+            components: {
+                transport: "HttpRelayTransport",
+                discovery: "RelayRoomPeerList",
+                envelope_codec: this.envelopeCodec.constructor.name,
+                topic_codec: this.topicCodec.constructor.name,
+            },
+            limits: {
+                max_message_bytes: this.maxMessageBytes,
+                max_future_drift_ms: this.maxFutureDriftMs,
+                max_past_drift_ms: this.maxPastDriftMs,
+            },
+            config: {
+                started: this.started,
+                topic_handler_count: this.handlers.size,
+                poll_interval_ms: this.pollIntervalMs,
+            },
+            peers: {
+                total: peerItems.length,
+                online: peerItems.length,
+                stale: 0,
+                items: peerItems,
+            },
+            stats: { ...this.stats },
+        };
+    }
+    async pollOnce() {
+        if (this.pollInFlight) {
+            this.stats.poll_skipped_inflight += 1;
+            return;
+        }
+        this.pollInFlight = true;
+        await this.maybeRefreshJoin("poll");
+        this.stats.poll_attempted += 1;
+        try {
+            const payload = await this.get(`/relay/poll?room=${encodeURIComponent(this.room)}&peer_id=${encodeURIComponent(this.peerId)}`);
+            this.lastPollAt = Date.now();
+            this.stats.poll_succeeded += 1;
+            this.currentPollDelayMs = this.pollIntervalMs;
+            const messages = Array.isArray(payload?.messages) ? payload.messages : [];
+            for (const message of messages) {
+                this.signalingMessagesReceivedTotal += 1;
+                this.onEnvelope(message?.envelope);
+            }
+            if (Array.isArray(payload?.peers)) {
+                this.updatePeersFromList(payload.peers);
+            }
+            else if (!this.lastPeerRefreshAt || Date.now() - this.lastPeerRefreshAt >= this.peerRefreshIntervalMs) {
+                await this.refreshPeers();
+            }
+        }
+        catch (error) {
+            this.currentPollDelayMs = Math.min(15_000, Math.max(this.pollIntervalMs, this.currentPollDelayMs * 2));
+            throw error;
+        }
+        finally {
+            this.pollInFlight = false;
+            if (this.started) {
+                this.scheduleNextPoll(this.currentPollDelayMs);
+            }
+        }
+    }
+    async refreshPeers() {
+        this.stats.peers_refresh_attempted += 1;
+        const payload = await this.get(`/peers?room=${encodeURIComponent(this.room)}`);
+        this.lastPeerRefreshAt = Date.now();
+        this.stats.peers_refresh_succeeded += 1;
+        const peerIds = Array.isArray(payload?.peers) ? payload.peers : [];
+        this.updatePeersFromList(peerIds);
+    }
+    onEnvelope(envelope) {
+        this.stats.received_total += 1;
+        const validated = (0, messageEnvelope_1.validateNetworkMessageEnvelope)(envelope, {
+            max_future_drift_ms: this.maxFutureDriftMs,
+            max_past_drift_ms: this.maxPastDriftMs,
+        });
+        if (!validated.ok || !validated.envelope) {
+            if (validated.reason === "timestamp_future_drift") {
+                this.stats.dropped_timestamp_future_drift += 1;
+            }
+            else if (validated.reason === "timestamp_past_drift") {
+                this.stats.dropped_timestamp_past_drift += 1;
+            }
+            else {
+                this.stats.dropped_malformed += 1;
+            }
+            return;
+        }
+        const message = validated.envelope;
+        if (message.source_peer_id === this.peerId) {
+            this.stats.dropped_self += 1;
+            return;
+        }
+        if (!message.topic.startsWith(`${this.namespace}:`)) {
+            this.stats.dropped_namespace_mismatch += 1;
+            return;
+        }
+        if (this.seenMessageIds.has(message.message_id)) {
+            return;
+        }
+        this.seenMessageIds.add(message.message_id);
+        if (this.seenMessageIds.size > 10000) {
+            const first = this.seenMessageIds.values().next().value;
+            if (first)
+                this.seenMessageIds.delete(first);
+        }
+        this.stats.received_validated += 1;
+        const topicKey = message.topic;
+        const topic = topicKey.slice(this.namespace.length + 1);
+        const handlers = this.handlers.get(topicKey);
+        if (!handlers || handlers.size === 0)
+            return;
+        const peer = this.peers.get(message.source_peer_id);
+        if (peer) {
+            peer.last_seen_at = Date.now();
+            peer.messages_seen += 1;
+        }
+        let payload;
+        try {
+            payload = this.topicCodec.decode(topic, message.payload);
+        }
+        catch {
+            this.stats.dropped_topic_decode_error += 1;
+            return;
+        }
+        for (const handler of handlers) {
+            try {
+                handler(payload);
+                this.stats.delivered_total += 1;
+            }
+            catch {
+                this.stats.dropped_handler_error += 1;
+            }
+        }
+    }
+    recordDiscovery(type, extra = {}) {
+        const event = {
+            id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            type,
+            at: Date.now(),
+            ...extra,
+        };
+        this.discoveryEvents.unshift(event);
+        this.discoveryEvents = this.discoveryEvents.slice(0, 200);
+        this.discoveryEventsTotal += 1;
+        this.lastDiscoveryEventAt = event.at;
+    }
+    async joinRoom(reason) {
+        this.stats.join_attempted += 1;
+        await this.post("/join", { room: this.room, peer_id: this.peerId });
+        this.lastJoinAt = Date.now();
+        this.stats.join_succeeded += 1;
+        this.recordDiscovery("join_ok", { endpoint: this.activeEndpoint, detail: reason });
+    }
+    async maybeRefreshJoin(reason) {
+        if (!this.lastJoinAt || Date.now() - this.lastJoinAt > Math.max(45_000, this.pollIntervalMs * 6)) {
+            await this.joinRoom(reason);
+        }
+    }
+    async get(path) {
+        return this.requestJson("GET", path);
+    }
+    async post(path, body) {
+        return this.requestJson("POST", path, body);
+    }
+    async requestJson(method, path, body) {
+        const errors = [];
+        for (let offset = 0; offset < this.signalingEndpoints.length; offset += 1) {
+            const index = (this.activeEndpointIndex + offset) % this.signalingEndpoints.length;
+            const endpoint = this.signalingEndpoints[index]?.replace(/\/+$/, "");
+            if (!endpoint)
+                continue;
+            let timeout = null;
+            try {
+                const controller = new AbortController();
+                timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+                const response = await fetch(`${endpoint}${path}`, {
+                    method,
+                    headers: method === "POST" ? { "content-type": "application/json" } : undefined,
+                    body: method === "POST" ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const responseText = (await response.text().catch(() => "")).trim();
+                    const detail = responseText ? `: ${responseText.slice(0, 200)}` : "";
+                    throw new Error(`${method} ${path} failed (${response.status})${detail}`);
+                }
+                this.activeEndpointIndex = index;
+                this.activeEndpoint = endpoint;
+                this.lastError = null;
+                return response.json();
+            }
+            catch (error) {
+                const isAbort = error instanceof Error && (error.name === "AbortError" || error.message === "This operation was aborted");
+                const message = isAbort
+                    ? `${method} ${path} timed out after ${this.requestTimeoutMs}ms`
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
+                errors.push(`${endpoint}: ${message}`);
+                this.stats.signaling_errors += 1;
+                this.lastError = message;
+                this.lastErrorAt = Date.now();
+                this.reconnectAttemptsTotal += 1;
+                this.recordDiscovery("signaling_error", { endpoint, detail: message });
+            }
+            finally {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+            }
+        }
+        throw new Error(errors.join(" | "));
+    }
+    updatePeersFromList(values) {
+        const peerIds = values.map((value) => String(value || "").trim()).filter(Boolean);
+        if (!peerIds.includes(this.peerId)) {
+            void this.joinRoom("self_missing_from_peers").catch(() => { });
+        }
+        const now = Date.now();
+        const next = new Map();
+        for (const peerId of peerIds) {
+            if (peerId === this.peerId)
+                continue;
+            const existing = this.peers.get(peerId);
+            if (!existing) {
+                this.recordDiscovery("peer_joined", { peer_id: peerId });
+            }
+            next.set(peerId, {
+                peer_id: peerId,
+                status: "online",
+                first_seen_at: existing?.first_seen_at ?? now,
+                last_seen_at: now,
+                messages_seen: existing?.messages_seen ?? 0,
+                reconnect_attempts: existing?.reconnect_attempts ?? 0,
+            });
+        }
+        for (const peerId of this.peers.keys()) {
+            if (!next.has(peerId)) {
+                this.recordDiscovery("peer_removed", { peer_id: peerId });
+            }
+        }
+        this.peers = next;
+    }
+    scheduleNextPoll(delayMs) {
+        if (this.poller) {
+            clearTimeout(this.poller);
+        }
+        const jitterMs = Math.floor(Math.random() * 400);
+        this.poller = setTimeout(() => {
+            this.pollOnce().catch(() => { });
+        }, Math.max(1000, delayMs + jitterMs));
+    }
+}
+exports.RelayPreviewAdapter = RelayPreviewAdapter;

package/node_modules/@silicaclaw/network/dist/transport/udpLanBroadcastTransport.d.ts

@@ -0,0 +1,23 @@
+import { NetworkTransport, TransportConfigSnapshot, TransportMessageMeta, TransportStats } from "../abstractions/transport";
+type UdpLanBroadcastTransportOptions = {
+    port?: number;
+    bindAddress?: string;
+    broadcastAddress?: string;
+};
+export declare class UdpLanBroadcastTransport implements NetworkTransport {
+    private socket;
+    private handlers;
+    private state;
+    private stats;
+    private port;
+    private bindAddress;
+    private broadcastAddress;
+    constructor(options?: UdpLanBroadcastTransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    onMessage(handler: (data: Buffer, meta: TransportMessageMeta) => void): () => void;
+    getStats(): TransportStats;
+    getConfig(): TransportConfigSnapshot;
+}
+export {};

package/node_modules/@silicaclaw/network/dist/transport/udpLanBroadcastTransport.js

@@ -0,0 +1,153 @@
+"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"));
+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 ?? 44123;
+        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/node_modules/@silicaclaw/network/dist/types.d.ts

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

package/node_modules/@silicaclaw/network/dist/types.js

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