clawnexus 0.2.8 → 0.3.0

package/dist/a2a/card.d.ts

@@ -0,0 +1,29 @@
+import type { ClawInstance } from "../types.js";
+export interface AgentSkill {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    examples?: string[];
+    inputModes?: string[];
+    outputModes?: string[];
+}
+export interface AgentCard {
+    name: string;
+    description: string;
+    url: string;
+    version: string;
+    capabilities: {
+        streaming: boolean;
+        pushNotifications: boolean;
+        stateTransitionHistory: boolean;
+    };
+    skills: AgentSkill[];
+    defaultInputModes: string[];
+    defaultOutputModes: string[];
+    provider: {
+        name: string;
+        url?: string;
+    };
+}
+export declare function buildAgentCard(instance: ClawInstance, daemonVersion: string): AgentCard;

package/dist/a2a/card.js

@@ -0,0 +1,30 @@
+"use strict";
+// A2A Agent Card generation — maps ClawInstance to A2A v0.3.0 Agent Card
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAgentCard = buildAgentCard;
+const DEFAULT_SKILL = {
+    id: "general-assistant",
+    name: "General Assistant",
+    description: "General-purpose AI assistant",
+    tags: ["general"],
+};
+function buildAgentCard(instance, daemonVersion) {
+    return {
+        name: instance.alias ?? instance.auto_name,
+        description: instance.display_name || instance.assistant_name,
+        url: `http://${instance.address}:17890`,
+        version: daemonVersion,
+        capabilities: {
+            streaming: false,
+            pushNotifications: false,
+            stateTransitionHistory: false,
+        },
+        skills: [DEFAULT_SKILL],
+        defaultInputModes: ["text/plain"],
+        defaultOutputModes: ["text/plain"],
+        provider: {
+            name: "ClawNexus",
+            url: "https://github.com/SilverstreamsAI/ClawNexus",
+        },
+    };
+}

package/dist/adapter/index.js

@@ -4,11 +4,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ADAPTERS = void 0;
 exports.getAdapter = getAdapter;
 exports.getAllAdapterPorts = getAllAdapterPorts;
+const openclaw_js_1 = require("./openclaw.js");
 const nanoclaw_js_1 = require("./nanoclaw.js");
 const nanobot_js_1 = require("./nanobot.js");
+const openfang_js_1 = require("./openfang.js");
 exports.ADAPTERS = [
+    new openclaw_js_1.OpenClawAdapter(),
     new nanoclaw_js_1.NanoClawAdapter(),
     new nanobot_js_1.NanoBotAdapter(),
+    new openfang_js_1.OpenFangAdapter(),
 ];
 function getAdapter(name) {
     return exports.ADAPTERS.find((a) => a.name === name);

package/dist/adapter/nanobot.d.ts

@@ -5,6 +5,7 @@ export declare class NanoBotAdapter implements FrameworkAdapter {
     readonly defaultPorts: number[];
     probe(host: string, port: number): Promise<ProbeResult | null>;
     toClawInstance(host: string, port: number, probe: ProbeResult): Partial<ClawInstance>;
+    healthCheck(host: string, port: number): Promise<boolean>;
     private probeHealth;
     private probeApiHealth;
     private extractProbeResult;

package/dist/adapter/nanobot.js

@@ -1,5 +1,5 @@
 "use strict";
-// NanoBot adapter — Python variant, default ports 8000/8080
+// NanoBot adapter — Python variant, default ports 18790/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 });
@@ -7,7 +7,7 @@ exports.NanoBotAdapter = void 0;
 const PROBE_TIMEOUT = 2_000;
 class NanoBotAdapter {
     name = "nanobot";
-    defaultPorts = [8000, 8080];
+    defaultPorts = [18790, 8000, 8080];
     async probe(host, port) {
         // Try /health first
         const healthResult = await this.probeHealth(host, port);
@@ -30,6 +30,21 @@ class NanoBotAdapter {
             implementation: "nanobot",
         };
     }
+    async healthCheck(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}/health`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            if (!res.ok)
+                return false;
+            const data = (await res.json());
+            return data.framework === "nanobot" || data.app === "nanobot" ||
+                (typeof data.python_version === "string" && this.defaultPorts.includes(port));
+        }
+        catch {
+            return false;
+        }
+    }
     async probeHealth(host, port) {
         try {
             const res = await fetch(`http://${host}:${port}/health`, {

package/dist/adapter/nanoclaw.d.ts

@@ -3,8 +3,25 @@ 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;
+    private _lastProjectDir;
+    probe(_host: string, _port: number): Promise<ProbeResult | null>;
+    probeLocal(): Promise<ProbeResult | null>;
+    healthCheckLocal(): Promise<boolean>;
+    toClawInstance(host: string, _port: number, probe: ProbeResult): Partial<ClawInstance>;
+    healthCheck(_host: string, _port: number): Promise<boolean>;
+    /** Scan /proc for Node.js processes whose cwd contains a nanoclaw package.json */
+    private _findFromProc;
+    /** Check common paths under home directory */
+    private _findFromCandidateDirs;
+    /** Check if a directory is a nanoclaw project */
+    private _isNanoClawDir;
+    /** Read package.json and verify it's nanoclaw */
+    private _readPackageJson;
+    /** Extract ASSISTANT_NAME from .env file */
+    private _readAssistantName;
+    /** Find a running process with cwd matching the project dir */
+    private _findRunningPid;
+    /** Count JSON files in data/ipc/{channel}/messages/ as a proxy for active tasks */
+    private _countIpcTasks;
+    private _fileExists;
 }

package/dist/adapter/nanoclaw.js

@@ -1,74 +1,259 @@
 "use strict";
-// NanoClaw adapter — TypeScript variant, default ports 3100/3101
-// Probe: /health → check for framework: "nanoclaw", fallback /api/info
+// NanoClaw adapter — ProjectProbe implementation
+// NanoClaw has no HTTP server, so discovery uses local filesystem probing:
+// /proc scan for running processes, package.json, .env, data/ipc/ directory.
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NanoClawAdapter = void 0;
-const PROBE_TIMEOUT = 2_000;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const NANOCLAW_PACKAGE_NAME = "nanoclaw";
+// Common paths where nanoclaw might be installed
+const CANDIDATE_DIRS = [
+    "nanoclaw",
+    "NanoClaw",
+    "projects/nanoclaw",
+    "projects/NanoClaw",
+];
 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);
+    defaultPorts = [];
+    // Cached project dir from last successful probe
+    _lastProjectDir = null;
+    async probe(_host, _port) {
+        return null;
+    }
+    async probeLocal() {
+        // 1. Try to find via running Node.js processes (/proc scan)
+        let projectDir = await this._findFromProc();
+        // 2. Fallback: scan common home directory paths
+        if (!projectDir) {
+            projectDir = await this._findFromCandidateDirs();
+        }
+        if (!projectDir)
+            return null;
+        this._lastProjectDir = projectDir;
+        // Read package.json for version
+        const pkgInfo = await this._readPackageJson(projectDir);
+        if (!pkgInfo)
+            return null; // not actually nanoclaw
+        // Read .env for ASSISTANT_NAME (optional)
+        const assistantName = await this._readAssistantName(projectDir);
+        // Check if process is running
+        const procInfo = await this._findRunningPid(projectDir);
+        // Count active IPC tasks (data/ipc/*/messages/*.json)
+        const activeTasks = await this._countIpcTasks(projectDir);
+        // Check if store/messages.db exists (has been run before)
+        const hasMessageDb = await this._fileExists(path.join(projectDir, "store", "messages.db"));
+        return {
+            name: NANOCLAW_PACKAGE_NAME,
+            version: pkgInfo.version,
+            display_name: assistantName ?? undefined,
+            metadata: {
+                project_dir: projectDir,
+                is_running: procInfo !== null,
+                pid: procInfo,
+                active_tasks: activeTasks,
+                has_message_db: hasMessageDb,
+            },
+        };
+    }
+    async healthCheckLocal() {
+        const projectDir = this._lastProjectDir;
+        if (!projectDir)
+            return false;
+        // Check if a nanoclaw process is running with this project dir
+        const pid = await this._findRunningPid(projectDir);
+        if (pid !== null)
+            return true;
+        // Fallback: check store/messages.db mtime (recent activity = likely alive)
+        try {
+            const dbPath = path.join(projectDir, "store", "messages.db");
+            const stat = await fs.promises.stat(dbPath);
+            const ageMs = Date.now() - stat.mtimeMs;
+            // Consider "healthy" if db was modified in last 5 minutes
+            return ageMs < 5 * 60 * 1000;
+        }
+        catch {
+            return false;
+        }
     }
-    toClawInstance(host, port, probe) {
+    toClawInstance(host, _port, probe) {
+        const meta = probe.metadata;
         return {
             agent_id: `nanoclaw@${host}`,
             assistant_name: probe.display_name ?? "",
             display_name: probe.display_name ?? "nanoclaw",
             lan_host: host,
             address: host,
-            gateway_port: port,
+            gateway_port: 0,
             tls: false,
-            discovery_source: "scan",
-            status: "online",
+            discovery_source: "local",
             implementation: "nanoclaw",
+            labels: meta?.project_dir ? { project_dir: meta.project_dir } : undefined,
         };
     }
-    async probeHealth(host, port) {
+    async healthCheck(_host, _port) {
+        return false;
+    }
+    /** Scan /proc for Node.js processes whose cwd contains a nanoclaw package.json */
+    async _findFromProc() {
+        if (process.platform !== "linux")
+            return null;
         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,
-                };
+            const entries = await fs.promises.readdir("/proc");
+            for (const entry of entries) {
+                // Only numeric dirs (PIDs)
+                if (!/^\d+$/.test(entry))
+                    continue;
+                try {
+                    const cwd = await fs.promises.readlink(`/proc/${entry}/cwd`);
+                    if (await this._isNanoClawDir(cwd)) {
+                        return cwd;
+                    }
+                }
+                catch {
+                    // Permission denied or process gone — skip
+                }
             }
-            return null;
         }
         catch {
-            return null;
+            // /proc not available
         }
+        return null;
     }
-    async probeApiInfo(host, port) {
+    /** Check common paths under home directory */
+    async _findFromCandidateDirs() {
+        const home = os.homedir();
+        for (const rel of CANDIDATE_DIRS) {
+            const dir = path.join(home, rel);
+            if (await this._isNanoClawDir(dir)) {
+                return dir;
+            }
+        }
+        return null;
+    }
+    /** Check if a directory is a nanoclaw project */
+    async _isNanoClawDir(dir) {
+        const info = await this._readPackageJson(dir);
+        return info !== null;
+    }
+    /** Read package.json and verify it's nanoclaw */
+    async _readPackageJson(dir) {
         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,
-                };
+            const raw = await fs.promises.readFile(path.join(dir, "package.json"), "utf-8");
+            const pkg = JSON.parse(raw);
+            if (pkg.name === NANOCLAW_PACKAGE_NAME) {
+                return { version: pkg.version };
+            }
+        }
+        catch {
+            // Not found or invalid
+        }
+        return null;
+    }
+    /** Extract ASSISTANT_NAME from .env file */
+    async _readAssistantName(dir) {
+        try {
+            const raw = await fs.promises.readFile(path.join(dir, ".env"), "utf-8");
+            const match = raw.match(/^ASSISTANT_NAME=(.*)$/m);
+            if (match?.[1]) {
+                return match[1].trim().replace(/^["']|["']$/g, "");
             }
-            return null;
         }
         catch {
+            // .env not found
+        }
+        return null;
+    }
+    /** Find a running process with cwd matching the project dir */
+    async _findRunningPid(dir) {
+        if (process.platform !== "linux")
             return null;
+        try {
+            const entries = await fs.promises.readdir("/proc");
+            for (const entry of entries) {
+                if (!/^\d+$/.test(entry))
+                    continue;
+                try {
+                    const cwd = await fs.promises.readlink(`/proc/${entry}/cwd`);
+                    if (cwd === dir) {
+                        return parseInt(entry, 10);
+                    }
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+        catch {
+            // /proc not available
+        }
+        return null;
+    }
+    /** Count JSON files in data/ipc/{channel}/messages/ as a proxy for active tasks */
+    async _countIpcTasks(dir) {
+        const ipcDir = path.join(dir, "data", "ipc");
+        try {
+            const channels = await fs.promises.readdir(ipcDir);
+            let count = 0;
+            for (const ch of channels) {
+                const messagesDir = path.join(ipcDir, ch, "messages");
+                try {
+                    const files = await fs.promises.readdir(messagesDir);
+                    count += files.filter((f) => f.endsWith(".json")).length;
+                }
+                catch {
+                    // messages dir doesn't exist for this channel
+                }
+            }
+            return count;
+        }
+        catch {
+            // data/ipc doesn't exist
+            return 0;
+        }
+    }
+    async _fileExists(filePath) {
+        try {
+            await fs.promises.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
         }
     }
 }

package/dist/adapter/openclaw.d.ts

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

package/dist/adapter/openclaw.js

@@ -0,0 +1,62 @@
+"use strict";
+// OpenClaw adapter — canonical OpenClaw (and compatible variants like GoClaw)
+// Probe: /__openclaw/control-ui-config.json → extract agentId, assistantName, displayName
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenClawAdapter = void 0;
+const PROBE_TIMEOUT = 2_000;
+const CONFIG_PATH = "/__openclaw/control-ui-config.json";
+class OpenClawAdapter {
+    name = "openclaw";
+    defaultPorts = [18789];
+    async probe(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}${CONFIG_PATH}`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            if (!res.ok)
+                return null;
+            const config = (await res.json());
+            if (!config.assistantAgentId)
+                return null;
+            return {
+                name: "openclaw",
+                display_name: config.displayName ?? config.assistantName ?? undefined,
+                metadata: {
+                    assistantAgentId: config.assistantAgentId,
+                    assistantName: config.assistantName,
+                    displayName: config.displayName,
+                },
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    toClawInstance(host, port, probe) {
+        const meta = probe.metadata;
+        return {
+            agent_id: meta?.assistantAgentId ?? `openclaw@${host}`,
+            assistant_name: meta?.assistantName ?? "",
+            display_name: meta?.displayName ?? meta?.assistantName ?? "",
+            lan_host: host,
+            address: host,
+            gateway_port: port,
+            tls: false,
+            discovery_source: "scan",
+            status: "online",
+            implementation: "openclaw",
+        };
+    }
+    async healthCheck(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}${CONFIG_PATH}`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.OpenClawAdapter = OpenClawAdapter;

package/dist/adapter/openfang.d.ts

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

package/dist/adapter/openfang.js

@@ -0,0 +1,88 @@
+"use strict";
+// OpenFang adapter — port 4200, REST API
+// Probe: /api/health → confirm OpenFang, identity from /.well-known/agent.json
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenFangAdapter = void 0;
+const PROBE_TIMEOUT = 2_000;
+class OpenFangAdapter {
+    name = "openfang";
+    defaultPorts = [4200];
+    async probe(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 (!this.isOpenFang(data))
+                return null;
+            // Try to get identity from /.well-known/agent.json
+            const agent = await this.fetchAgentJson(host, port);
+            return {
+                name: "openfang",
+                version: data.version ?? agent?.version,
+                display_name: agent?.display_name ?? agent?.name,
+                metadata: {
+                    agent_id: agent?.agent_id,
+                    agent_name: agent?.name,
+                },
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    toClawInstance(host, port, probe) {
+        const meta = probe.metadata;
+        return {
+            agent_id: meta?.agent_id ?? `openfang@${host}`,
+            assistant_name: meta?.agent_name ?? "",
+            display_name: probe.display_name ?? "openfang",
+            lan_host: host,
+            address: host,
+            gateway_port: port,
+            tls: false,
+            discovery_source: "scan",
+            status: "online",
+            implementation: "openfang",
+        };
+    }
+    async healthCheck(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}/api/health`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            if (!res.ok)
+                return false;
+            const data = (await res.json());
+            return data.status === "ok";
+        }
+        catch {
+            return false;
+        }
+    }
+    isOpenFang(data) {
+        // Confirm OpenFang by framework field or status shape
+        if (data.framework === "openfang")
+            return true;
+        // Heuristic: /api/health with status: "ok" on default port
+        if (data.status === "ok")
+            return true;
+        return false;
+    }
+    async fetchAgentJson(host, port) {
+        try {
+            const res = await fetch(`http://${host}:${port}/.well-known/agent.json`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT),
+            });
+            if (!res.ok)
+                return null;
+            return (await res.json());
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.OpenFangAdapter = OpenFangAdapter;

package/dist/adapter/types.d.ts

@@ -10,4 +10,7 @@ export interface FrameworkAdapter {
     readonly defaultPorts: number[];
     probe(host: string, port: number): Promise<ProbeResult | null>;
     toClawInstance(host: string, port: number, probe: ProbeResult): Partial<ClawInstance>;
+    healthCheck(host: string, port: number): Promise<boolean>;
+    probeLocal?(): Promise<ProbeResult | null>;
+    healthCheckLocal?(): Promise<boolean>;
 }

package/dist/api/server.d.ts

@@ -39,6 +39,7 @@ export interface DiagnosticsDeps {
     unreachable: UnreachableInstance[];
 }
 export declare function registerDiagnosticsRoutes(app: FastifyInstance, deps: DiagnosticsDeps): void;
+export declare function registerA2aRoutes(app: FastifyInstance, store: RegistryStore, daemonVersion: string): void;
 export interface DaemonOptions {
     port?: number;
     host?: string;

package/dist/api/server.js

@@ -10,6 +10,7 @@ exports.registerAgentRoutes = registerAgentRoutes;
 exports.registerRegistryRoutes = registerRegistryRoutes;
 exports.registerInstanceRoutes = registerInstanceRoutes;
 exports.registerDiagnosticsRoutes = registerDiagnosticsRoutes;
+exports.registerA2aRoutes = registerA2aRoutes;
 exports.startDaemon = startDaemon;
 const fastify_1 = __importDefault(require("fastify"));
 const store_js_1 = require("../registry/store.js");
@@ -27,6 +28,9 @@ const client_js_1 = require("../registry/client.js");
 const auto_register_js_1 = require("../registry/auto-register.js");
 const discovery_js_1 = require("../registry/discovery.js");
 const connector_js_1 = require("../relay/connector.js");
+const card_js_1 = require("../a2a/card.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const PORT = parseInt(process.env.CLAWNEXUS_PORT ?? "17890", 10);
 const HOST = process.env.CLAWNEXUS_HOST ?? "127.0.0.1";
 function registerRelayRoutes(app, getConnector) {
@@ -301,6 +305,30 @@ function registerDiagnosticsRoutes(app, deps) {
         };
     });
 }
+function registerA2aRoutes(app, store, daemonVersion) {
+    // A2A standard well-known endpoint — returns card for the local (is_self) instance
+    app.get("/.well-known/agent-card.json", async (_request, reply) => {
+        const self = store.getAll().find((i) => i.is_self);
+        if (!self) {
+            return reply.status(404).send({ error: "No local instance discovered" });
+        }
+        return (0, card_js_1.buildAgentCard)(self, daemonVersion);
+    });
+    // All instances as Agent Cards
+    app.get("/a2a/cards", async () => {
+        const instances = store.getAll();
+        const cards = instances.map((i) => (0, card_js_1.buildAgentCard)(i, daemonVersion));
+        return { count: cards.length, cards };
+    });
+    // Single instance Agent Card by name
+    app.get("/a2a/cards/:name", async (request, reply) => {
+        const inst = store.resolve(request.params.name);
+        if (!inst) {
+            return reply.status(404).send({ error: "Instance not found" });
+        }
+        return (0, card_js_1.buildAgentCard)(inst, daemonVersion);
+    });
+}
 async function startDaemon(options = {}) {
     const port = options.port ?? PORT;
     const host = options.host ?? HOST;
@@ -390,6 +418,9 @@ async function startDaemon(options = {}) {
         getAutoRegister: () => autoRegister,
         unreachable,
     });
+    // A2A Agent Card routes
+    const daemonPkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "../../package.json"), "utf-8"));
+    registerA2aRoutes(app, store, daemonPkg.version);
     // 9. Initialize Registry integration (non-fatal — LAN must work without it)
     let identityKeys = null;
     let registryClient = null;

package/dist/discovery/broadcast.js

@@ -46,7 +46,6 @@ const CDP_PORT = 17891;
 const TCP_PROBE_TIMEOUT = 2_000;
 const ANNOUNCE_INTERVAL_BASE = 60_000;
 const ANNOUNCE_JITTER = 10_000;
-const CONFIG_PATH = "/__openclaw/control-ui-config.json";
 class BroadcastDiscovery extends node_events_1.EventEmitter {
     store;
     getLocalInstance;
@@ -274,12 +273,14 @@ class BroadcastDiscovery extends node_events_1.EventEmitter {
         });
     }
     async _tcpProbe(address, port) {
-        const url = `http://${address}:${port}${CONFIG_PATH}`;
+        // Quick HTTP liveness check — just confirm the port is alive.
+        // Framework identification is left to HealthChecker / subsequent scans.
         try {
-            const res = await fetch(url, {
+            const res = await fetch(`http://${address}:${port}/`, {
                 signal: AbortSignal.timeout(TCP_PROBE_TIMEOUT),
             });
-            return res.ok;
+            // Any HTTP response (including 404, 500) means the port is alive
+            return res.status > 0;
         }
         catch {
             return false;

package/dist/health/checker.d.ts

@@ -11,4 +11,8 @@ export declare class HealthChecker extends EventEmitter {
     stop(): void;
     checkAll(): Promise<void>;
     private checkOne;
+    /** OpenClaw-specific health check with name updates */
+    private checkOpenClaw;
+    /** Fallback health check for instances without a known adapter */
+    private genericHttpCheck;
 }

package/dist/health/checker.js

@@ -1,9 +1,11 @@
 "use strict";
 // Health Checker — periodically pings known instances and updates status
 // Enhanced with dual-channel connectivity detection
+// Adapter-aware: uses framework-specific health checks for non-OpenClaw instances
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HealthChecker = void 0;
 const node_events_1 = require("node:events");
+const index_js_1 = require("../adapter/index.js");
 const CHECK_INTERVAL = 30_000;
 const PING_TIMEOUT = 5_000;
 const CONFIG_PATH = "/__openclaw/control-ui-config.json";
@@ -41,36 +43,51 @@ class HealthChecker extends node_events_1.EventEmitter {
         if (inst.is_self)
             return;
         const networkKey = this.store.networkKey(inst.address, inst.gateway_port);
-        const protocol = inst.tls ? "https" : "http";
-        const url = `${protocol}://${inst.address}:${inst.gateway_port}${CONFIG_PATH}`;
+        const impl = inst.implementation ?? "openclaw";
         const now = new Date().toISOString();
         let lanOk = false;
         let lanLatency;
         let unreachableReason;
-        try {
-            const start = performance.now();
-            const res = await fetch(url, {
-                signal: AbortSignal.timeout(PING_TIMEOUT),
-            });
-            lanLatency = Math.round(performance.now() - start);
-            if (res.ok) {
-                lanOk = true;
-                const config = (await res.json());
-                inst.last_seen = now;
-                if (config.assistantName) {
-                    inst.assistant_name = config.assistantName;
+        if (impl === "openclaw" || impl === "goclaw") {
+            // OpenClaw path: detailed check with name updates (original behavior)
+            const result = await this.checkOpenClaw(inst, now);
+            lanOk = result.ok;
+            lanLatency = result.latency;
+            unreachableReason = result.reason;
+        }
+        else {
+            // Non-OpenClaw: use adapter healthCheck
+            const adapter = (0, index_js_1.getAdapter)(impl);
+            if (adapter) {
+                try {
+                    const start = performance.now();
+                    // Use healthCheckLocal for port-0 instances (no HTTP server)
+                    if (inst.gateway_port === 0 && adapter.healthCheckLocal) {
+                        lanOk = await adapter.healthCheckLocal();
+                    }
+                    else {
+                        lanOk = await adapter.healthCheck(inst.address, inst.gateway_port);
+                    }
+                    lanLatency = Math.round(performance.now() - start);
+                    if (lanOk) {
+                        inst.last_seen = now;
+                    }
+                    else {
+                        unreachableReason = "Health check failed";
+                    }
                 }
-                if (config.displayName) {
-                    inst.display_name = config.displayName;
+                catch (err) {
+                    unreachableReason = err instanceof Error ? err.message : "Connection failed";
                 }
             }
             else {
-                unreachableReason = `HTTP ${res.status}`;
+                // Unknown implementation: generic HTTP check
+                const result = await this.genericHttpCheck(inst, now);
+                lanOk = result.ok;
+                lanLatency = result.latency;
+                unreachableReason = result.reason;
             }
         }
-        catch (err) {
-            unreachableReason = err instanceof Error ? err.message : "Connection failed";
-        }
         // Check relay availability
         const relayAvailable = this.relayChecker?.(inst.agent_id) ?? false;
         // Update connectivity
@@ -104,5 +121,52 @@ class HealthChecker extends node_events_1.EventEmitter {
             });
         }
     }
+    /** OpenClaw-specific health check with name updates */
+    async checkOpenClaw(inst, now) {
+        const protocol = inst.tls ? "https" : "http";
+        const url = `${protocol}://${inst.address}:${inst.gateway_port}${CONFIG_PATH}`;
+        try {
+            const start = performance.now();
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(PING_TIMEOUT),
+            });
+            const latency = Math.round(performance.now() - start);
+            if (res.ok) {
+                const config = (await res.json());
+                inst.last_seen = now;
+                if (config.assistantName) {
+                    inst.assistant_name = config.assistantName;
+                }
+                if (config.displayName) {
+                    inst.display_name = config.displayName;
+                }
+                return { ok: true, latency };
+            }
+            return { ok: false, latency, reason: `HTTP ${res.status}` };
+        }
+        catch (err) {
+            return { ok: false, reason: err instanceof Error ? err.message : "Connection failed" };
+        }
+    }
+    /** Fallback health check for instances without a known adapter */
+    async genericHttpCheck(inst, now) {
+        const protocol = inst.tls ? "https" : "http";
+        const url = `${protocol}://${inst.address}:${inst.gateway_port}/`;
+        try {
+            const start = performance.now();
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(PING_TIMEOUT),
+            });
+            const latency = Math.round(performance.now() - start);
+            if (res.ok) {
+                inst.last_seen = now;
+                return { ok: true, latency };
+            }
+            return { ok: false, latency, reason: `HTTP ${res.status}` };
+        }
+        catch (err) {
+            return { ok: false, reason: err instanceof Error ? err.message : "Connection failed" };
+        }
+    }
 }
 exports.HealthChecker = HealthChecker;

package/dist/local/probe.d.ts

@@ -11,5 +11,9 @@ export declare class LocalProbe extends EventEmitter {
     start(): Promise<void>;
     stop(): void;
     private _markOffline;
+    /** Mark offline any previously-known self instances that were not rediscovered this cycle */
+    private _markOfflineStaleSelf;
     probe(): Promise<ClawInstance | null>;
+    /** Original OpenClaw probe logic (kept as primary path for backward compatibility) */
+    private probeOpenClaw;
 }

package/dist/local/probe.js

@@ -1,6 +1,7 @@
 "use strict";
-// LocalProbe — detects OpenClaw instance on localhost and registers it
+// LocalProbe — detects AI instances on localhost and registers them
 // Runs on daemon startup, then periodically re-checks
+// Adapter-aware: tries all registered adapters on their default ports
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -38,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalProbe = void 0;
 const node_events_1 = require("node:events");
 const os = __importStar(require("node:os"));
+const index_js_1 = require("../adapter/index.js");
 const LOCAL_HOST = "127.0.0.1";
 const DEFAULT_PORT = 18789;
 const CONFIG_PATH = "/__openclaw/control-ui-config.json";
@@ -71,8 +73,8 @@ class LocalProbe extends node_events_1.EventEmitter {
             this.timer = null;
         }
     }
-    _markOffline() {
-        const existing = this.store.getByNetworkKey(LOCAL_HOST, this.port);
+    _markOffline(port) {
+        const existing = this.store.getByNetworkKey(LOCAL_HOST, port);
         if (existing && existing.status !== "offline") {
             this.store.upsert({
                 ...existing,
@@ -81,21 +83,135 @@ class LocalProbe extends node_events_1.EventEmitter {
             });
         }
     }
+    /** Mark offline any previously-known self instances that were not rediscovered this cycle */
+    _markOfflineStaleSelf(staleKeys) {
+        for (const key of staleKeys) {
+            const [address, portStr] = key.split(":");
+            this._markOffline(Number(portStr));
+        }
+    }
     async probe() {
-        const url = `http://${LOCAL_HOST}:${this.port}${CONFIG_PATH}`;
+        // Snapshot all current is_self instances so we can mark stale ones offline later
+        const previousSelfKeys = new Set(this.store
+            .getAll()
+            .filter((inst) => inst.is_self)
+            .map((inst) => `${inst.address}:${inst.gateway_port}`));
+        // 1. Try OpenClaw on the configured port (backward-compatible primary path)
+        const openClawResult = await this.probeOpenClaw(this.port);
+        if (openClawResult) {
+            previousSelfKeys.delete(`${LOCAL_HOST}:${this.port}`);
+            this._markOfflineStaleSelf(previousSelfKeys);
+            return openClawResult;
+        }
+        // 2. Try all adapters on their default ports (skip OpenClaw on this.port, already tried)
+        let found = null;
+        for (const adapter of index_js_1.ADAPTERS) {
+            if (adapter.name === "openclaw")
+                continue; // already tried above
+            // Try probeLocal first (for frameworks without HTTP servers, e.g. NanoClaw)
+            if (adapter.probeLocal) {
+                const probeResult = await adapter.probeLocal();
+                if (probeResult) {
+                    const now = new Date().toISOString();
+                    const partial = adapter.toClawInstance(LOCAL_HOST, 0, probeResult);
+                    const instance = {
+                        agent_id: partial.agent_id ?? `${adapter.name}@localhost`,
+                        auto_name: "",
+                        assistant_name: partial.assistant_name ?? "",
+                        display_name: partial.display_name ?? adapter.name,
+                        lan_host: os.hostname(),
+                        address: LOCAL_HOST,
+                        gateway_port: partial.gateway_port ?? 0,
+                        tls: false,
+                        discovery_source: "local",
+                        network_scope: "local",
+                        status: "online",
+                        last_seen: now,
+                        discovered_at: now,
+                        implementation: partial.implementation,
+                        connectivity: {
+                            lan_reachable: false,
+                            relay_available: false,
+                            preferred_channel: "local",
+                            last_lan_check: now,
+                        },
+                        is_self: true,
+                        labels: partial.labels,
+                    };
+                    this.store.upsert(instance);
+                    this.emit("local:discovered", instance);
+                    previousSelfKeys.delete(`${LOCAL_HOST}:${instance.gateway_port}`);
+                    found = instance;
+                    break;
+                }
+            }
+            // Then try HTTP probe on default ports
+            if (!found) {
+                for (const port of adapter.defaultPorts) {
+                    const probeResult = await adapter.probe(LOCAL_HOST, port);
+                    if (probeResult) {
+                        const now = new Date().toISOString();
+                        const partial = adapter.toClawInstance(LOCAL_HOST, port, probeResult);
+                        const instance = {
+                            agent_id: partial.agent_id ?? `${adapter.name}@localhost`,
+                            auto_name: "",
+                            assistant_name: partial.assistant_name ?? "",
+                            display_name: partial.display_name ?? adapter.name,
+                            lan_host: os.hostname(),
+                            address: LOCAL_HOST,
+                            gateway_port: port,
+                            tls: false,
+                            discovery_source: "local",
+                            network_scope: "local",
+                            status: "online",
+                            last_seen: now,
+                            discovered_at: now,
+                            implementation: partial.implementation,
+                            connectivity: {
+                                lan_reachable: true,
+                                relay_available: false,
+                                preferred_channel: "local",
+                                last_lan_check: now,
+                            },
+                            is_self: true,
+                        };
+                        this.store.upsert(instance);
+                        this.emit("local:discovered", instance);
+                        previousSelfKeys.delete(`${LOCAL_HOST}:${port}`);
+                        found = instance;
+                        break;
+                    }
+                }
+            }
+            if (found)
+                break;
+        }
+        if (found) {
+            this._markOfflineStaleSelf(previousSelfKeys);
+            return found;
+        }
+        // Nothing found
+        this.localAgentId = null;
+        this._markOfflineStaleSelf(previousSelfKeys);
+        this.emit("local:unavailable");
+        return null;
+    }
+    /** Original OpenClaw probe logic (kept as primary path for backward compatibility) */
+    async probeOpenClaw(port) {
+        const url = `http://${LOCAL_HOST}:${port}${CONFIG_PATH}`;
         try {
             const res = await fetch(url, {
                 signal: AbortSignal.timeout(PROBE_TIMEOUT),
             });
             if (!res.ok) {
-                this._markOffline();
-                this.emit("local:unreachable", { reason: `HTTP ${res.status}` });
+                // Port responded but not valid OpenClaw — don't mark offline or emit unreachable,
+                // because another adapter may be occupying this port. Let the adapter loop try.
                 return null;
             }
             const config = (await res.json());
             if (!config.assistantAgentId) {
-                this._markOffline();
-                this.emit("local:unreachable", { reason: "missing assistantAgentId" });
+                // Has an HTTP server but no assistantAgentId — not a valid OpenClaw instance.
+                // Don't mark offline; another adapter may match this endpoint.
                 return null;
             }
             this.localAgentId = config.assistantAgentId;
@@ -107,7 +223,7 @@ class LocalProbe extends node_events_1.EventEmitter {
                 display_name: config.displayName ?? config.assistantName ?? "",
                 lan_host: os.hostname(),
                 address: LOCAL_HOST,
-                gateway_port: this.port,
+                gateway_port: port,
                 tls: false,
                 discovery_source: "local",
                 network_scope: "local",
@@ -128,9 +244,7 @@ class LocalProbe extends node_events_1.EventEmitter {
             return instance;
         }
         catch {
-            this.localAgentId = null;
-            this._markOffline();
-            this.emit("local:unavailable");
+            // OpenClaw not running on this port — don't emit yet, try adapters first
             return null;
         }
     }

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export type ClawImplementation = "openclaw" | "goclaw" | "zeroclaw" | "picoclaw" | "nanoclaw" | "nanobot" | "unknown";
+export type ClawImplementation = "openclaw" | "goclaw" | "zeroclaw" | "picoclaw" | "nanoclaw" | "nanobot" | "openfang" | "unknown";
 export interface ClawInstance {
     agent_id: string;
     auto_name: string;

package/package.json

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