clawnexus 0.2.6 → 0.2.8

package/dist/adapter/index.d.ts

@@ -0,0 +1,4 @@
+import type { FrameworkAdapter } from "./types.js";
+export declare const ADAPTERS: readonly FrameworkAdapter[];
+export declare function getAdapter(name: string): FrameworkAdapter | undefined;
+export declare function getAllAdapterPorts(): number[];

package/dist/adapter/index.js

@@ -0,0 +1,24 @@
+"use strict";
+// Adapter registry — central place to register framework adapters
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADAPTERS = void 0;
+exports.getAdapter = getAdapter;
+exports.getAllAdapterPorts = getAllAdapterPorts;
+const nanoclaw_js_1 = require("./nanoclaw.js");
+const nanobot_js_1 = require("./nanobot.js");
+exports.ADAPTERS = [
+    new nanoclaw_js_1.NanoClawAdapter(),
+    new nanobot_js_1.NanoBotAdapter(),
+];
+function getAdapter(name) {
+    return exports.ADAPTERS.find((a) => a.name === name);
+}
+function getAllAdapterPorts() {
+    const ports = new Set();
+    for (const adapter of exports.ADAPTERS) {
+        for (const port of adapter.defaultPorts) {
+            ports.add(port);
+        }
+    }
+    return [...ports].sort((a, b) => a - b);
+}

package/dist/adapter/nanobot.d.ts

@@ -0,0 +1,11 @@
+import type { ClawInstance } from "../types.js";
+import type { FrameworkAdapter, ProbeResult } from "./types.js";
+export declare class NanoBotAdapter implements FrameworkAdapter {
+    readonly name = "nanobot";
+    readonly defaultPorts: number[];
+    probe(host: string, port: number): Promise<ProbeResult | null>;
+    toClawInstance(host: string, port: number, probe: ProbeResult): Partial<ClawInstance>;
+    private probeHealth;
+    private probeApiHealth;
+    private extractProbeResult;
+}

package/dist/adapter/nanobot.js

@@ -0,0 +1,82 @@
+"use strict";
+// NanoBot adapter — Python variant, default ports 8000/8080
+// Probe: /health → check for framework/app: "nanobot", fallback /api/health
+// Heuristic: python_version field on expected port → infer nanobot
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NanoBotAdapter = void 0;
+const PROBE_TIMEOUT = 2_000;
+class NanoBotAdapter {
+    name = "nanobot";
+    defaultPorts = [8000, 8080];
+    async probe(host, port) {
+        // Try /health first
+        const healthResult = await this.probeHealth(host, port);
+        if (healthResult)
+            return healthResult;
+        // Fallback: /api/health
+        return this.probeApiHealth(host, port);
+    }
+    toClawInstance(host, port, probe) {
+        return {
+            agent_id: `nanobot@${host}`,
+            assistant_name: probe.display_name ?? "",
+            display_name: probe.display_name ?? "nanobot",
+            lan_host: host,
+            address: host,
+            gateway_port: port,
+            tls: false,
+            discovery_source: "scan",
+            status: "online",
+            implementation: "nanobot",
+        };
+    }
+    async probeHealth(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}/health`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            if (data.framework === "nanobot" || data.app === "nanobot") {
+                return this.extractProbeResult(data);
+            }
+            // Heuristic: python_version on expected port → infer nanobot
+            if (typeof data.python_version === "string" && this.defaultPorts.includes(port)) {
+                return this.extractProbeResult(data);
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async probeApiHealth(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}/api/health`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            if (data.framework === "nanobot" || data.app === "nanobot") {
+                return this.extractProbeResult(data);
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    extractProbeResult(data) {
+        return {
+            name: "nanobot",
+            version: typeof data.version === "string" ? data.version : undefined,
+            display_name: typeof data.name === "string" ? data.name : undefined,
+            metadata: typeof data.python_version === "string"
+                ? { python_version: data.python_version }
+                : undefined,
+        };
+    }
+}
+exports.NanoBotAdapter = NanoBotAdapter;

package/dist/adapter/nanoclaw.d.ts

@@ -0,0 +1,10 @@
+import type { ClawInstance } from "../types.js";
+import type { FrameworkAdapter, ProbeResult } from "./types.js";
+export declare class NanoClawAdapter implements FrameworkAdapter {
+    readonly name = "nanoclaw";
+    readonly defaultPorts: number[];
+    probe(host: string, port: number): Promise<ProbeResult | null>;
+    toClawInstance(host: string, port: number, probe: ProbeResult): Partial<ClawInstance>;
+    private probeHealth;
+    private probeApiInfo;
+}

package/dist/adapter/nanoclaw.js

@@ -0,0 +1,75 @@
+"use strict";
+// NanoClaw adapter — TypeScript variant, default ports 3100/3101
+// Probe: /health → check for framework: "nanoclaw", fallback /api/info
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NanoClawAdapter = void 0;
+const PROBE_TIMEOUT = 2_000;
+class NanoClawAdapter {
+    name = "nanoclaw";
+    defaultPorts = [3100, 3101];
+    async probe(host, port) {
+        // Try /health first
+        const healthResult = await this.probeHealth(host, port);
+        if (healthResult)
+            return healthResult;
+        // Fallback: /api/info
+        return this.probeApiInfo(host, port);
+    }
+    toClawInstance(host, port, probe) {
+        return {
+            agent_id: `nanoclaw@${host}`,
+            assistant_name: probe.display_name ?? "",
+            display_name: probe.display_name ?? "nanoclaw",
+            lan_host: host,
+            address: host,
+            gateway_port: port,
+            tls: false,
+            discovery_source: "scan",
+            status: "online",
+            implementation: "nanoclaw",
+        };
+    }
+    async probeHealth(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}/health`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            if (data.framework === "nanoclaw") {
+                return {
+                    name: "nanoclaw",
+                    version: typeof data.version === "string" ? data.version : undefined,
+                    display_name: typeof data.name === "string" ? data.name : undefined,
+                };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async probeApiInfo(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}/api/info`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            if (data.framework === "nanoclaw") {
+                return {
+                    name: "nanoclaw",
+                    version: typeof data.version === "string" ? data.version : undefined,
+                    display_name: typeof data.name === "string" ? data.name : undefined,
+                };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.NanoClawAdapter = NanoClawAdapter;

package/dist/adapter/types.d.ts

@@ -0,0 +1,13 @@
+import type { ClawInstance } from "../types.js";
+export interface ProbeResult {
+    name: string;
+    version?: string;
+    display_name?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface FrameworkAdapter {
+    readonly name: string;
+    readonly defaultPorts: number[];
+    probe(host: string, port: number): Promise<ProbeResult | null>;
+    toClawInstance(host: string, port: number, probe: ProbeResult): Partial<ClawInstance>;
+}

package/dist/adapter/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Framework adapter interface — pluggable probe logic for non-OpenClaw variants
+// that don't share port 18789 or serve /__openclaw/control-ui-config.json
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/index.js

@@ -156,6 +156,7 @@ function printTable(instances) {
     }
     const header = {
         name: "NAME",
+        impl: "IMPL",
         address: "ADDRESS",
         status: "STATUS",
         channel: "CHANNEL",
@@ -166,6 +167,7 @@ function printTable(instances) {
         const baseName = i.alias ?? i.auto_name;
         return {
             name: i.is_self ? `${baseName} (self)` : baseName,
+            impl: i.implementation ?? "-",
             address: `${i.address}:${i.gateway_port}`,
             status: i.status,
             channel: getChannel(i),
@@ -175,15 +177,16 @@ function printTable(instances) {
     });
     const colWidths = {
         name: Math.max(header.name.length, ...rows.map((r) => r.name.length)),
+        impl: Math.max(header.impl.length, ...rows.map((r) => r.impl.length)),
         address: Math.max(header.address.length, ...rows.map((r) => r.address.length)),
         status: Math.max(header.status.length, ...rows.map((r) => r.status.length)),
         channel: Math.max(header.channel.length, ...rows.map((r) => r.channel.length)),
         source: Math.max(header.source.length, ...rows.map((r) => r.source.length)),
         lastSeen: Math.max(header.lastSeen.length, ...rows.map((r) => r.lastSeen.length)),
     };
-    const line = (r) => `${r.name.padEnd(colWidths.name)}  ${r.address.padEnd(colWidths.address)}  ${r.status.padEnd(colWidths.status)}  ${r.channel.padEnd(colWidths.channel)}  ${r.source.padEnd(colWidths.source)}  ${r.lastSeen}`;
+    const line = (r) => `${r.name.padEnd(colWidths.name)}  ${r.impl.padEnd(colWidths.impl)}  ${r.address.padEnd(colWidths.address)}  ${r.status.padEnd(colWidths.status)}  ${r.channel.padEnd(colWidths.channel)}  ${r.source.padEnd(colWidths.source)}  ${r.lastSeen}`;
     console.log(line(header));
-    console.log("-".repeat(colWidths.name + colWidths.address + colWidths.status + colWidths.channel + colWidths.source + colWidths.lastSeen + 10));
+    console.log("-".repeat(colWidths.name + colWidths.impl + colWidths.address + colWidths.status + colWidths.channel + colWidths.source + colWidths.lastSeen + 12));
     for (const row of rows) {
         console.log(line(row));
     }
@@ -404,6 +407,8 @@ async function cmdInfo(args) {
         const inst = data;
         console.log(`Auto Name:     ${inst.auto_name}${inst.is_self ? " (self)" : ""}`);
         console.log(`Agent ID:      ${inst.agent_id}`);
+        if (inst.implementation)
+            console.log(`Implementation: ${inst.implementation}`);
         console.log(`Display Name:  ${inst.display_name}`);
         console.log(`Assistant:     ${inst.assistant_name}`);
         if (inst.alias)

package/dist/health/checker.js

@@ -1,6 +1,6 @@
 "use strict";
 // Health Checker — periodically pings known instances and updates status
-// Enhanced with dual-channel connectivity detection (TICKET-021)
+// Enhanced with dual-channel connectivity detection
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HealthChecker = void 0;
 const node_events_1 = require("node:events");

package/dist/index.d.ts

@@ -6,6 +6,10 @@ export { HealthChecker } from './health/checker.js';
 export { LocalProbe } from './local/probe.js';
 export { ActiveScanner } from './scanner/active.js';
 export type { ScanOptions } from './scanner/active.js';
+export { ADAPTERS, getAdapter, getAllAdapterPorts } from './adapter/index.js';
+export { NanoClawAdapter } from './adapter/nanoclaw.js';
+export { NanoBotAdapter } from './adapter/nanobot.js';
+export type { FrameworkAdapter, ProbeResult } from './adapter/types.js';
 export { BroadcastDiscovery } from './discovery/broadcast.js';
 export { registerRelayRoutes, registerInstanceRoutes, registerAgentRoutes, registerDiagnosticsRoutes, registerRegistryRoutes, startDaemon } from './api/server.js';
 export type { DaemonOptions, DaemonHandle, AgentDeps, DiagnosticsDeps, RegistryDeps } from './api/server.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtocolError = exports.isExpired = exports.validatePayload = exports.parseEnvelope = exports.createEnvelope = exports.AgentRouter = exports.TaskManager = exports.PolicyEngine = exports.RelayConnector = exports.RemoteDiscovery = exports.AutoRegister = exports.RegistryError = exports.RegistryClient = exports.getPublicKeyString = exports.sign = exports.loadOrCreateKeys = exports.startDaemon = exports.registerRegistryRoutes = exports.registerDiagnosticsRoutes = exports.registerAgentRoutes = exports.registerInstanceRoutes = exports.registerRelayRoutes = exports.BroadcastDiscovery = exports.ActiveScanner = exports.LocalProbe = exports.HealthChecker = exports.MdnsListener = exports.NotFoundError = exports.AliasConflictError = exports.AliasError = exports.RegistryStore = void 0;
+exports.ProtocolError = exports.isExpired = exports.validatePayload = exports.parseEnvelope = exports.createEnvelope = exports.AgentRouter = exports.TaskManager = exports.PolicyEngine = exports.RelayConnector = exports.RemoteDiscovery = exports.AutoRegister = exports.RegistryError = exports.RegistryClient = exports.getPublicKeyString = exports.sign = exports.loadOrCreateKeys = exports.startDaemon = exports.registerRegistryRoutes = exports.registerDiagnosticsRoutes = exports.registerAgentRoutes = exports.registerInstanceRoutes = exports.registerRelayRoutes = exports.BroadcastDiscovery = exports.NanoBotAdapter = exports.NanoClawAdapter = exports.getAllAdapterPorts = exports.getAdapter = exports.ADAPTERS = exports.ActiveScanner = exports.LocalProbe = exports.HealthChecker = exports.MdnsListener = exports.NotFoundError = exports.AliasConflictError = exports.AliasError = exports.RegistryStore = void 0;
 var store_js_1 = require("./registry/store.js");
 Object.defineProperty(exports, "RegistryStore", { enumerable: true, get: function () { return store_js_1.RegistryStore; } });
 Object.defineProperty(exports, "AliasError", { enumerable: true, get: function () { return store_js_1.AliasError; } });
@@ -14,6 +14,14 @@ var probe_js_1 = require("./local/probe.js");
 Object.defineProperty(exports, "LocalProbe", { enumerable: true, get: function () { return probe_js_1.LocalProbe; } });
 var active_js_1 = require("./scanner/active.js");
 Object.defineProperty(exports, "ActiveScanner", { enumerable: true, get: function () { return active_js_1.ActiveScanner; } });
+var index_js_1 = require("./adapter/index.js");
+Object.defineProperty(exports, "ADAPTERS", { enumerable: true, get: function () { return index_js_1.ADAPTERS; } });
+Object.defineProperty(exports, "getAdapter", { enumerable: true, get: function () { return index_js_1.getAdapter; } });
+Object.defineProperty(exports, "getAllAdapterPorts", { enumerable: true, get: function () { return index_js_1.getAllAdapterPorts; } });
+var nanoclaw_js_1 = require("./adapter/nanoclaw.js");
+Object.defineProperty(exports, "NanoClawAdapter", { enumerable: true, get: function () { return nanoclaw_js_1.NanoClawAdapter; } });
+var nanobot_js_1 = require("./adapter/nanobot.js");
+Object.defineProperty(exports, "NanoBotAdapter", { enumerable: true, get: function () { return nanobot_js_1.NanoBotAdapter; } });
 var broadcast_js_1 = require("./discovery/broadcast.js");
 Object.defineProperty(exports, "BroadcastDiscovery", { enumerable: true, get: function () { return broadcast_js_1.BroadcastDiscovery; } });
 var server_js_1 = require("./api/server.js");

package/dist/local/probe.js

@@ -114,6 +114,7 @@ class LocalProbe extends node_events_1.EventEmitter {
                 status: "online",
                 last_seen: now,
                 discovered_at: now,
+                implementation: "openclaw",
                 connectivity: {
                     lan_reachable: true,
                     relay_available: false,

package/dist/mdns/listener.js

@@ -93,7 +93,7 @@ class MdnsListener extends node_events_1.EventEmitter {
             // Fetch agent_id from the OpenClaw instance
             const agentId = await this.fetchAgentId(address, port, txt["gatewayTls"] === "1");
             if (!agentId) {
-                // Record unreachable instance for diagnostics (TICKET-021)
+                // Record unreachable instance for diagnostics
                 this.emit("mdns:unreachable", {
                     address,
                     port,

package/dist/registry/client.js

@@ -1,5 +1,5 @@
 "use strict";
-// RegistryClient — HTTP client for ClawNexus-Cloud public registry
+// RegistryClient — HTTP client for the ClawNexus public registry
 // Handles register, resolve, getToken, checkName with signature and retry logic
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegistryClient = exports.RegistryError = void 0;

package/dist/registry/store.js

@@ -201,6 +201,8 @@ class RegistryStore extends node_events_1.EventEmitter {
             // Preserve registry fields
             instance.claw_name = instance.claw_name ?? existing.claw_name;
             instance.owner_pubkey = instance.owner_pubkey ?? existing.owner_pubkey;
+            // Preserve implementation (prefer new value if provided)
+            instance.implementation = instance.implementation ?? existing.implementation;
             this.instances.set(key, instance);
             this.scheduleDirtyFlush();
             this.emit("upsert", instance);
@@ -315,6 +317,7 @@ class RegistryStore extends node_events_1.EventEmitter {
             labels: existing.labels ?? incoming.labels,
             connectivity: incoming.connectivity ?? existing.connectivity,
             is_self: existing.is_self || incoming.is_self,
+            implementation: incoming.implementation ?? existing.implementation,
         };
     }
     /** Numeric priority for network scope: local > vpn > public */

package/dist/scanner/active.d.ts

@@ -18,6 +18,7 @@ export declare class ActiveScanner extends EventEmitter {
     private generateIPs;
     private probeAll;
     private probeHost;
+    private probeConfigEndpoint;
     /**
      * Resolve a stable lan_host for scanned instances to enable multi-NIC dedup.
      *

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" | "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.6",
+  "version": "0.2.8",
   "description": "ClawNexus daemon and CLI — AI instance registry for OpenClaw",
   "license": "MIT",
   "author": "alan-silverstreams <alan@silverstream.tech>",
@@ -24,6 +24,12 @@
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "bin": {
     "clawnexus": "dist/cli/index.js"
   },