@silicaclaw/cli 2026.3.19-9 → 2026.3.20-2

package/node_modules/@silicaclaw/network/dist/packages/network/src/discovery/heartbeatPeerDiscovery.d.ts

@@ -0,0 +1,28 @@
+import { PeerDiscovery, PeerDiscoveryConfigSnapshot, PeerDiscoveryContext, PeerDiscoveryStats, PeerSnapshot } from "../abstractions/peerDiscovery";
+import { NetworkMessageEnvelope } from "../abstractions/messageEnvelope";
+type HeartbeatPeerDiscoveryOptions = {
+    heartbeatIntervalMs?: number;
+    staleAfterMs?: number;
+    removeAfterMs?: number;
+    topic?: string;
+};
+export declare class HeartbeatPeerDiscovery implements PeerDiscovery {
+    private peers;
+    private timer;
+    private context;
+    private heartbeatIntervalMs;
+    private staleAfterMs;
+    private removeAfterMs;
+    private topic;
+    private stats;
+    constructor(options?: HeartbeatPeerDiscoveryOptions);
+    start(context: PeerDiscoveryContext): Promise<void>;
+    stop(): Promise<void>;
+    observeEnvelope(envelope: NetworkMessageEnvelope): void;
+    listPeers(): PeerSnapshot[];
+    getStats(): PeerDiscoveryStats;
+    getConfig(): PeerDiscoveryConfigSnapshot;
+    private sendHeartbeat;
+    private reconcilePeerHealth;
+}
+export {};

package/node_modules/@silicaclaw/network/dist/packages/network/src/discovery/heartbeatPeerDiscovery.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatPeerDiscovery = void 0;
+class HeartbeatPeerDiscovery {
+    peers = new Map();
+    timer = null;
+    context = null;
+    heartbeatIntervalMs;
+    staleAfterMs;
+    removeAfterMs;
+    topic;
+    stats = {
+        observe_calls: 0,
+        peers_added: 0,
+        peers_removed: 0,
+        peers_marked_stale: 0,
+        heartbeat_sent: 0,
+        heartbeat_send_errors: 0,
+        reconcile_runs: 0,
+        last_observed_at: 0,
+        last_heartbeat_at: 0,
+        last_reconcile_at: 0,
+        last_error_at: 0,
+    };
+    constructor(options = {}) {
+        this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? 12_000;
+        this.staleAfterMs = options.staleAfterMs ?? 45_000;
+        this.removeAfterMs = options.removeAfterMs ?? 180_000;
+        this.topic = options.topic ?? "__discovery/heartbeat";
+    }
+    async start(context) {
+        this.context = context;
+        this.reconcilePeerHealth();
+        await this.sendHeartbeat();
+        this.timer = setInterval(async () => {
+            await this.sendHeartbeat();
+            this.reconcilePeerHealth();
+        }, this.heartbeatIntervalMs);
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    observeEnvelope(envelope) {
+        this.stats.observe_calls += 1;
+        this.stats.last_observed_at = Date.now();
+        if (!this.context) {
+            return;
+        }
+        if (envelope.source_peer_id === this.context.self_peer_id) {
+            return;
+        }
+        const now = Date.now();
+        const existing = this.peers.get(envelope.source_peer_id);
+        if (!existing) {
+            this.stats.peers_added += 1;
+        }
+        this.peers.set(envelope.source_peer_id, {
+            peer_id: envelope.source_peer_id,
+            first_seen_at: existing?.first_seen_at ?? now,
+            last_seen_at: now,
+            status: "online",
+            stale_since_at: undefined,
+            messages_seen: (existing?.messages_seen ?? 0) + 1,
+            meta: envelope.topic === this.topic && typeof envelope.payload === "object" && envelope.payload !== null
+                ? envelope.payload
+                : existing?.meta,
+        });
+    }
+    listPeers() {
+        this.reconcilePeerHealth();
+        return Array.from(this.peers.values()).sort((a, b) => {
+            const score = (p) => (p.status === "online" ? 1 : 0);
+            const byStatus = score(b) - score(a);
+            if (byStatus !== 0) {
+                return byStatus;
+            }
+            return b.last_seen_at - a.last_seen_at;
+        });
+    }
+    getStats() {
+        return { ...this.stats };
+    }
+    getConfig() {
+        return {
+            discovery: "heartbeat-peer-discovery",
+            heartbeat_topic: this.topic,
+            heartbeat_interval_ms: this.heartbeatIntervalMs,
+            stale_after_ms: this.staleAfterMs,
+            remove_after_ms: this.removeAfterMs,
+        };
+    }
+    async sendHeartbeat() {
+        if (!this.context) {
+            return;
+        }
+        try {
+            await this.context.publishControl(this.topic, {
+                kind: "heartbeat",
+                at: Date.now(),
+            });
+            this.stats.heartbeat_sent += 1;
+            this.stats.last_heartbeat_at = Date.now();
+        }
+        catch {
+            this.stats.heartbeat_send_errors += 1;
+            this.stats.last_error_at = Date.now();
+        }
+    }
+    reconcilePeerHealth() {
+        const now = Date.now();
+        this.stats.reconcile_runs += 1;
+        this.stats.last_reconcile_at = now;
+        for (const [peerId, peer] of this.peers.entries()) {
+            const age = now - peer.last_seen_at;
+            if (age > this.removeAfterMs) {
+                this.peers.delete(peerId);
+                this.stats.peers_removed += 1;
+                continue;
+            }
+            if (age > this.staleAfterMs) {
+                if (peer.status !== "stale") {
+                    this.stats.peers_marked_stale += 1;
+                }
+                this.peers.set(peerId, {
+                    ...peer,
+                    status: "stale",
+                    stale_since_at: peer.stale_since_at ?? now,
+                });
+                continue;
+            }
+            if (peer.status !== "online") {
+                this.peers.set(peerId, {
+                    ...peer,
+                    status: "online",
+                    stale_since_at: undefined,
+                });
+            }
+        }
+    }
+}
+exports.HeartbeatPeerDiscovery = HeartbeatPeerDiscovery;

package/node_modules/@silicaclaw/network/dist/packages/network/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./types";
+export * from "./mock";
+export * from "./localEventBus";
+export * from "./realPreview";
+export * from "./webrtcPreview";
+export * from "./relayPreview";
+export * from "./abstractions/messageEnvelope";
+export * from "./abstractions/topicCodec";
+export * from "./abstractions/transport";
+export * from "./abstractions/peerDiscovery";
+export * from "./codec/jsonMessageEnvelopeCodec";
+export * from "./codec/jsonTopicCodec";
+export * from "./discovery/heartbeatPeerDiscovery";
+export * from "./transport/udpLanBroadcastTransport";

package/node_modules/@silicaclaw/network/dist/packages/network/src/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./mock"), exports);
+__exportStar(require("./localEventBus"), exports);
+__exportStar(require("./realPreview"), exports);
+__exportStar(require("./webrtcPreview"), exports);
+__exportStar(require("./relayPreview"), exports);
+__exportStar(require("./abstractions/messageEnvelope"), exports);
+__exportStar(require("./abstractions/topicCodec"), exports);
+__exportStar(require("./abstractions/transport"), exports);
+__exportStar(require("./abstractions/peerDiscovery"), exports);
+__exportStar(require("./codec/jsonMessageEnvelopeCodec"), exports);
+__exportStar(require("./codec/jsonTopicCodec"), exports);
+__exportStar(require("./discovery/heartbeatPeerDiscovery"), exports);
+__exportStar(require("./transport/udpLanBroadcastTransport"), exports);

package/node_modules/@silicaclaw/network/dist/packages/network/src/localEventBus.d.ts

@@ -0,0 +1,9 @@
+import { NetworkAdapter } from "./types";
+export declare class LocalEventBusAdapter implements NetworkAdapter {
+    private started;
+    private emitter;
+    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/packages/network/src/localEventBus.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalEventBusAdapter = void 0;
+const events_1 = require("events");
+const CHANNEL_NAME = "silicaclaw-local-event-bus";
+function getNodeBus() {
+    const g = globalThis;
+    if (!g.__silicaclaw_bus) {
+        g.__silicaclaw_bus = new events_1.EventEmitter();
+    }
+    return g.__silicaclaw_bus;
+}
+class LocalEventBusAdapter {
+    started = false;
+    emitter = getNodeBus();
+    async start() {
+        this.started = true;
+    }
+    async stop() {
+        this.started = false;
+    }
+    async publish(topic, data) {
+        if (!this.started) {
+            return;
+        }
+        if (typeof BroadcastChannel !== "undefined") {
+            const channel = new BroadcastChannel(CHANNEL_NAME);
+            channel.postMessage({ topic, data });
+            channel.close();
+            return;
+        }
+        setImmediate(() => this.emitter.emit(topic, data));
+    }
+    subscribe(topic, handler) {
+        if (typeof BroadcastChannel !== "undefined") {
+            const channel = new BroadcastChannel(CHANNEL_NAME);
+            channel.onmessage = (event) => {
+                if (event.data?.topic === topic) {
+                    handler(event.data.data);
+                }
+            };
+            return;
+        }
+        this.emitter.on(topic, handler);
+    }
+}
+exports.LocalEventBusAdapter = LocalEventBusAdapter;

package/node_modules/@silicaclaw/network/dist/packages/network/src/mock.d.ts

@@ -0,0 +1,8 @@
+import { NetworkAdapter } from "./types";
+export declare class MockNetworkAdapter implements NetworkAdapter {
+    private started;
+    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/packages/network/src/mock.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockNetworkAdapter = void 0;
+const events_1 = require("events");
+const bus = new events_1.EventEmitter();
+class MockNetworkAdapter {
+    started = false;
+    async start() {
+        this.started = true;
+    }
+    async stop() {
+        this.started = false;
+    }
+    async publish(topic, data) {
+        if (!this.started) {
+            return;
+        }
+        setImmediate(() => bus.emit(topic, data));
+    }
+    subscribe(topic, handler) {
+        bus.on(topic, handler);
+    }
+}
+exports.MockNetworkAdapter = MockNetworkAdapter;

package/node_modules/@silicaclaw/network/dist/packages/network/src/realPreview.d.ts

@@ -0,0 +1,105 @@
+import { NetworkAdapter } from "./types";
+import { MessageEnvelopeCodec } from "./abstractions/messageEnvelope";
+import { TopicCodec } from "./abstractions/topicCodec";
+import { NetworkTransport } from "./abstractions/transport";
+import { PeerDiscovery, PeerSnapshot } from "./abstractions/peerDiscovery";
+type RealNetworkAdapterPreviewOptions = {
+    peerId?: string;
+    namespace?: string;
+    transport?: NetworkTransport;
+    envelopeCodec?: MessageEnvelopeCodec;
+    topicCodec?: TopicCodec;
+    peerDiscovery?: PeerDiscovery;
+    maxMessageBytes?: number;
+    dedupeWindowMs?: number;
+    dedupeMaxEntries?: number;
+    maxFutureDriftMs?: number;
+    maxPastDriftMs?: number;
+};
+type NetworkDiagnostics = {
+    adapter: string;
+    peer_id: string;
+    namespace: string;
+    components: {
+        transport: string;
+        discovery: string;
+        envelope_codec: string;
+        topic_codec: string;
+    };
+    limits: {
+        max_message_bytes: number;
+        dedupe_window_ms: number;
+        dedupe_max_entries: number;
+        max_future_drift_ms: number;
+        max_past_drift_ms: number;
+    };
+    config: {
+        started: boolean;
+        topic_handler_count: number;
+        transport: ReturnType<NonNullable<NetworkTransport["getConfig"]>> | null;
+        discovery: ReturnType<NonNullable<PeerDiscovery["getConfig"]>> | null;
+    };
+    peers: {
+        total: number;
+        online: number;
+        stale: number;
+        items: PeerSnapshot[];
+    };
+    stats: {
+        publish_attempted: number;
+        publish_sent: number;
+        received_total: number;
+        delivered_total: number;
+        dropped_duplicate: number;
+        dropped_self: 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_topic_decode_error: number;
+        dropped_handler_error: number;
+        send_errors: number;
+        discovery_errors: number;
+        start_errors: number;
+        stop_errors: number;
+        received_validated: number;
+    };
+    transport_stats: ReturnType<NonNullable<NetworkTransport["getStats"]>> | null;
+    discovery_stats: ReturnType<NonNullable<PeerDiscovery["getStats"]>> | null;
+};
+export declare class RealNetworkAdapterPreview implements NetworkAdapter {
+    private started;
+    private peerId;
+    private namespace;
+    private transport;
+    private envelopeCodec;
+    private topicCodec;
+    private peerDiscovery;
+    private maxMessageBytes;
+    private dedupeWindowMs;
+    private dedupeMaxEntries;
+    private maxFutureDriftMs;
+    private maxPastDriftMs;
+    private seenMessageIds;
+    private offTransportMessage;
+    private handlers;
+    private stats;
+    constructor(options?: RealNetworkAdapterPreviewOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    publish(topic: string, data: any): Promise<void>;
+    subscribe(topic: string, handler: (data: any) => void): void;
+    listPeers(): PeerSnapshot[];
+    getDiagnostics(): NetworkDiagnostics;
+    private onTransportMessage;
+    private topicKey;
+    private stripNamespace;
+    private isDuplicateMessage;
+    private cleanupSeenMessageIds;
+    private isValidTopic;
+    private normalizeNamespace;
+    private errorMessage;
+}
+export {};