clawnexus 0.2.7 → 0.3.0

package/dist/scanner/active.js

@@ -38,11 +38,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActiveScanner = void 0;
 const node_events_1 = require("node:events");
 const os = __importStar(require("node:os"));
+const fingerprint_js_1 = require("./fingerprint.js");
 const wireguard_js_1 = require("./wireguard.js");
+const index_js_1 = require("../adapter/index.js");
 const CONCURRENCY = 50;
 const TIMEOUT_PER_HOST = 2_000;
 const DEFAULT_PORT = 18789;
 const CONFIG_PATH = "/__openclaw/control-ui-config.json";
+// Default ports for all known implementations
+const BUILTIN_PORTS = [
+    18789, // OpenClaw, GoClaw
+    42617, // ZeroClaw
+    18790, // PicoClaw
+];
+const DEFAULT_SCAN_PORTS = [...new Set([...BUILTIN_PORTS, ...(0, index_js_1.getAllAdapterPorts)()])];
 class ActiveScanner extends node_events_1.EventEmitter {
     store;
     scanning = false;
@@ -71,8 +80,8 @@ class ActiveScanner extends node_events_1.EventEmitter {
             }
             // 2. Scan subnets (skip if only explicit targets were given)
             if (!hasExplicitTargets) {
-                const ports = options?.ports ?? [DEFAULT_PORT];
-                const allPorts = [...new Set([DEFAULT_PORT, ...ports])];
+                const ports = options?.ports ?? DEFAULT_SCAN_PORTS;
+                const allPorts = [...new Set([...DEFAULT_SCAN_PORTS, ...ports])];
                 const wgInfo = await (0, wireguard_js_1.detectWireGuard)();
                 const subnets = this.detectSubnets(wgInfo);
                 for (const si of subnets) {
@@ -160,25 +169,18 @@ class ActiveScanner extends node_events_1.EventEmitter {
         return discovered;
     }
     async probeHost(host, port = DEFAULT_PORT, networkScope = "local") {
-        const url = `http://${host}:${port}${CONFIG_PATH}`;
-        try {
-            const res = await fetch(url, {
-                signal: AbortSignal.timeout(TIMEOUT_PER_HOST),
-            });
-            if (!res.ok)
-                return null;
-            const config = (await res.json());
-            if (!config.assistantAgentId)
-                return null;
-            // Resolve lan_host: prefer known hostname from existing registry entries
-            // over raw IP to enable multi-NIC deduplication
-            const lan_host = this.resolveHostForDedup(host, port, config.assistantAgentId);
+        // Try OpenClaw-compatible config endpoint first
+        const configResult = await this.probeConfigEndpoint(host, port);
+        if (configResult) {
+            // Got config — identify variant (openclaw vs goclaw)
+            const fp = await (0, fingerprint_js_1.identifyImplementation)(host, port, configResult);
+            const lan_host = this.resolveHostForDedup(host, port, configResult.assistantAgentId);
             const now = new Date().toISOString();
             return {
-                agent_id: config.assistantAgentId,
-                auto_name: "", // will be assigned by store.upsert()
-                assistant_name: config.assistantName ?? "",
-                display_name: config.displayName ?? config.assistantName ?? "",
+                agent_id: configResult.assistantAgentId,
+                auto_name: "",
+                assistant_name: configResult.assistantName ?? "",
+                display_name: configResult.displayName ?? configResult.assistantName ?? "",
                 lan_host,
                 address: host,
                 gateway_port: port,
@@ -188,8 +190,60 @@ class ActiveScanner extends node_events_1.EventEmitter {
                 status: "online",
                 last_seen: now,
                 discovered_at: now,
+                implementation: fp.implementation,
+            };
+        }
+        // No config endpoint — try fingerprint-only identification (zeroclaw, picoclaw)
+        const fp = await (0, fingerprint_js_1.identifyImplementation)(host, port, null);
+        if (fp.implementation !== "unknown") {
+            const now = new Date().toISOString();
+            return {
+                agent_id: `${fp.implementation}@${host}`,
+                auto_name: "",
+                assistant_name: "",
+                display_name: fp.implementation,
+                lan_host: host,
+                address: host,
+                gateway_port: port,
+                tls: false,
+                discovery_source: "scan",
+                network_scope: networkScope,
+                status: "online",
+                last_seen: now,
+                discovered_at: now,
+                implementation: fp.implementation,
             };
         }
+        // Fingerprint unknown — try framework adapters as final fallback
+        for (const adapter of index_js_1.ADAPTERS) {
+            const probe = await adapter.probe(host, port);
+            if (probe) {
+                const now = new Date().toISOString();
+                const partial = adapter.toClawInstance(host, port, probe);
+                return {
+                    ...partial,
+                    auto_name: "",
+                    network_scope: networkScope,
+                    last_seen: now,
+                    discovered_at: now,
+                };
+            }
+        }
+        return null;
+    }
+    async probeConfigEndpoint(host, port) {
+        const url = `http://${host}:${port}${CONFIG_PATH}`;
+        try {
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(TIMEOUT_PER_HOST),
+            });
+            if (!res.ok)
+                return null;
+            const config = (await res.json());
+            if (!config.assistantAgentId)
+                return null;
+            return config;
+        }
         catch {
             return null;
         }

package/dist/scanner/fingerprint.d.ts

@@ -0,0 +1,22 @@
+import type { ClawImplementation, ControlUiConfig } from "../types.js";
+export interface FingerprintResult {
+    implementation: ClawImplementation;
+    confidence: number;
+}
+/**
+ * Identify the implementation variant of a host.
+ *
+ * Probe order (highest to lowest confidence):
+ *   1. /.well-known/claw-identity.json — ClawLink Protocol (self-declared)
+ *   2. /__openclaw/control-ui-config.json analysis — field count heuristic
+ *   3. /health endpoint — ZeroClaw vs PicoClaw differentiation
+ */
+export declare function identifyImplementation(host: string, port: number, config?: ControlUiConfig | null): Promise<FingerprintResult>;
+/**
+ * Detect implementation from a 404 error response body.
+ * Auxiliary signal — low confidence, used as tiebreaker.
+ *
+ * Go net/http: "404 page not found\n" (plain text)
+ * Fastify (Node.js): JSON {"message":"Route ... not found","error":"Not Found","statusCode":404}
+ */
+export declare function detect404Format(body: string): "go" | "fastify" | "unknown";

package/dist/scanner/fingerprint.js

@@ -0,0 +1,135 @@
+"use strict";
+// Fingerprint identification — multi-signal cascade to identify OpenClaw variants
+//
+// Supported implementations:
+//   openclaw  — Node.js, port 18789, serves /__openclaw/control-ui-config.json
+//   goclaw   — Go (chi), port 18789, serves /__openclaw/control-ui-config.json (compat mode)
+//   zeroclaw — Rust (Axum), port 42617, /health with "paired" field
+//   picoclaw — Go (net/http), port 18790, /health + /ready (K8s-style probes)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifyImplementation = identifyImplementation;
+exports.detect404Format = detect404Format;
+const FINGERPRINT_TIMEOUT = 2_000;
+/**
+ * Identify the implementation variant of a host.
+ *
+ * Probe order (highest to lowest confidence):
+ *   1. /.well-known/claw-identity.json — ClawLink Protocol (self-declared)
+ *   2. /__openclaw/control-ui-config.json analysis — field count heuristic
+ *   3. /health endpoint — ZeroClaw vs PicoClaw differentiation
+ */
+async function identifyImplementation(host, port, config) {
+    // Signal 1: ClawLink identity endpoint (highest priority)
+    const clawlink = await probeClawIdentity(host, port);
+    if (clawlink)
+        return clawlink;
+    // Signal 2: If we got a control-ui-config, analyze it
+    if (config) {
+        return analyzeConfig(config);
+    }
+    // Signal 3: No config → check /health for non-OpenClaw variants
+    const healthResult = await probeHealth(host, port);
+    if (healthResult)
+        return healthResult;
+    return { implementation: "unknown", confidence: 0.1 };
+}
+async function probeClawIdentity(host, port) {
+    try {
+        const res = await fetch(`http://${host}:${port}/.well-known/claw-identity.json`, { signal: AbortSignal.timeout(FINGERPRINT_TIMEOUT) });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        if (data.implementation && typeof data.implementation === "string") {
+            const impl = data.implementation.toLowerCase();
+            const known = [
+                "openclaw", "goclaw", "zeroclaw", "picoclaw", "nanoclaw", "nanobot",
+            ];
+            return {
+                implementation: known.includes(impl) ? impl : "unknown",
+                confidence: 1.0,
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Analyze control-ui-config.json to distinguish OpenClaw from GoClaw.
+ *
+ * OpenClaw's config is feature-rich (>8 fields), while GoClaw's compat mode
+ * returns a minimal subset (<6 fields, missing UI-specific keys).
+ */
+function analyzeConfig(config) {
+    const knownFields = Object.keys(config);
+    const fieldCount = knownFields.length;
+    // GoClaw compat mode: minimal config, typically <6 fields
+    // and missing OpenClaw-specific UI fields
+    const uiFields = [
+        "controlUi", "assistantUrl", "webSearchEnabled",
+        "customInstructions", "tools",
+    ];
+    const hasUiFields = uiFields.some((f) => f in config);
+    if (fieldCount < 6 && !hasUiFields) {
+        return { implementation: "goclaw", confidence: 0.7 };
+    }
+    return { implementation: "openclaw", confidence: 0.8 };
+}
+/**
+ * Probe /health to identify ZeroClaw or PicoClaw.
+ *
+ * ZeroClaw: /health returns JSON with "paired" + "runtime" fields
+ * PicoClaw: /health + /ready both return 200 (K8s-style)
+ */
+async function probeHealth(host, port) {
+    try {
+        const res = await fetch(`http://${host}:${port}/health`, {
+            signal: AbortSignal.timeout(FINGERPRINT_TIMEOUT),
+        });
+        if (!res.ok)
+            return null;
+        const text = await res.text();
+        // ZeroClaw: JSON with "paired" field
+        try {
+            const data = JSON.parse(text);
+            if ("paired" in data) {
+                return { implementation: "zeroclaw", confidence: 0.9 };
+            }
+        }
+        catch {
+            // Not JSON, continue checking
+        }
+        // PicoClaw: /health OK + /ready also OK
+        const readyRes = await fetch(`http://${host}:${port}/ready`, {
+            signal: AbortSignal.timeout(FINGERPRINT_TIMEOUT),
+        });
+        if (readyRes.ok) {
+            return { implementation: "picoclaw", confidence: 0.8 };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect implementation from a 404 error response body.
+ * Auxiliary signal — low confidence, used as tiebreaker.
+ *
+ * Go net/http: "404 page not found\n" (plain text)
+ * Fastify (Node.js): JSON {"message":"Route ... not found","error":"Not Found","statusCode":404}
+ */
+function detect404Format(body) {
+    if (body.trim() === "404 page not found")
+        return "go";
+    try {
+        const data = JSON.parse(body);
+        if (data.statusCode === 404 && typeof data.error === "string")
+            return "fastify";
+    }
+    catch {
+        // Not JSON
+    }
+    return "unknown";
+}

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+export type ClawImplementation = "openclaw" | "goclaw" | "zeroclaw" | "picoclaw" | "nanoclaw" | "nanobot" | "openfang" | "unknown";
 export interface ClawInstance {
     agent_id: string;
     auto_name: string;
@@ -18,6 +19,7 @@ export interface ClawInstance {
     is_self?: boolean;
     claw_name?: string;
     owner_pubkey?: string;
+    implementation?: ClawImplementation;
     labels?: Record<string, string>;
 }
 export interface Connectivity {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawnexus",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "description": "ClawNexus daemon and CLI — AI instance registry for OpenClaw",
   "license": "MIT",
   "author": "alan-silverstreams <alan@silverstream.tech>",