clawnexus 0.3.0 → 0.3.1

package/dist/api/server.js

@@ -22,6 +22,7 @@ const probe_js_1 = require("../local/probe.js");
 const engine_js_1 = require("../agent/engine.js");
 const tasks_js_1 = require("../agent/tasks.js");
 const router_js_1 = require("../agent/router.js");
+const executor_js_1 = require("../agent/executor.js");
 const broadcast_js_1 = require("../discovery/broadcast.js");
 const keys_js_1 = require("../crypto/keys.js");
 const client_js_1 = require("../registry/client.js");
@@ -29,11 +30,12 @@ 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 services_js_1 = require("../agent/services.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) {
+function registerRelayRoutes(app, getConnector, getTokenRefresher) {
     app.post("/relay/connect", async (request, reply) => {
         const connector = getConnector();
         if (!connector) {
@@ -47,6 +49,17 @@ function registerRelayRoutes(app, getConnector) {
                 error: "Missing target_claw_id",
             });
         }
+        // Refresh auth token before JOIN (relay JWTs expire after 5 min)
+        const refresher = getTokenRefresher?.();
+        if (refresher) {
+            try {
+                const freshToken = await refresher();
+                connector.updateAuthToken(freshToken);
+            }
+            catch (err) {
+                app.log.warn(`Token refresh before JOIN failed: ${err}`);
+            }
+        }
         connector.join(target_claw_id);
         return { status: "connecting", target: target_claw_id };
     });
@@ -71,7 +84,33 @@ function registerRelayRoutes(app, getConnector) {
     });
 }
 function registerAgentRoutes(app, deps) {
-    const { engine, tasks, getRouter } = deps;
+    const { engine, tasks, getRouter, getExecutor, skillsRegistry } = deps;
+    // --- Skills ---
+    app.get("/agent/skills", async () => {
+        if (!skillsRegistry) {
+            return { skills: [], status: { source: "not_initialized" } };
+        }
+        return { skills: skillsRegistry.getSkills(), status: skillsRegistry.getStatus() };
+    });
+    app.post("/agent/skills/refresh", async () => {
+        if (!skillsRegistry) {
+            return { status: "error", message: "Skills registry not initialized" };
+        }
+        const ok = await skillsRegistry.refresh();
+        return {
+            status: ok ? "ok" : "error",
+            skills: skillsRegistry.getSkills(),
+            ...skillsRegistry.getStatus(),
+        };
+    });
+    // --- Executor status ---
+    app.get("/agent/executor/status", async () => {
+        const executor = getExecutor();
+        if (!executor) {
+            return { gw_state: "not_initialized", queue_length: 0, executing: [], max_concurrent: 0 };
+        }
+        return executor.getStatus();
+    });
     // --- Policy ---
     app.get("/agent/policy", async () => engine.getConfig());
     app.put("/agent/policy", async (request) => {
@@ -305,19 +344,20 @@ function registerDiagnosticsRoutes(app, deps) {
         };
     });
 }
-function registerA2aRoutes(app, store, daemonVersion) {
+function registerA2aRoutes(app, store, daemonVersion, skillsRegistry) {
     // 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);
+        return (0, card_js_1.buildAgentCard)(self, daemonVersion, skillsRegistry?.getSkills());
     });
     // 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));
+        const skills = skillsRegistry?.getSkills();
+        const cards = instances.map((i) => (0, card_js_1.buildAgentCard)(i, daemonVersion, skills));
         return { count: cards.length, cards };
     });
     // Single instance Agent Card by name
@@ -326,7 +366,7 @@ function registerA2aRoutes(app, store, daemonVersion) {
         if (!inst) {
             return reply.status(404).send({ error: "Instance not found" });
         }
-        return (0, card_js_1.buildAgentCard)(inst, daemonVersion);
+        return (0, card_js_1.buildAgentCard)(inst, daemonVersion, skillsRegistry?.getSkills());
     });
 }
 async function startDaemon(options = {}) {
@@ -355,6 +395,13 @@ async function startDaemon(options = {}) {
     await engine.init();
     const taskManager = new tasks_js_1.TaskManager();
     await taskManager.init();
+    // 6b. Create TaskExecutor
+    const taskExecutor = new executor_js_1.TaskExecutor({
+        tasks: taskManager,
+        maxConcurrent: engine.getConfig().max_concurrent_tasks,
+    });
+    // 6c. Create SkillsRegistry
+    const skillsRegistry = new services_js_1.SkillsRegistry();
     // 7. Detect WireGuard interfaces
     const wgInfo = await (0, wireguard_js_1.detectWireGuard)();
     // 8. Create and configure Fastify app
@@ -378,7 +425,7 @@ async function startDaemon(options = {}) {
     app.get("/health", async () => ({
         status: "ok",
         service: "clawnexus-daemon",
-        version: "0.4.0",
+        version: "0.3.1",
         timestamp: new Date().toISOString(),
         components: {
             registry: { instances: store.size },
@@ -401,12 +448,23 @@ async function startDaemon(options = {}) {
     // Instance management routes
     registerInstanceRoutes(app, store, scanner);
     // Relay routes
-    registerRelayRoutes(app, () => connector);
+    registerRelayRoutes(app, () => connector, () => {
+        const rc = registryClient;
+        const clawName = autoRegister?.clawName;
+        if (!rc || !clawName)
+            return null;
+        return async () => {
+            const result = await rc.getToken(clawName);
+            return result.token;
+        };
+    });
     // Agent routes (Layer B)
     registerAgentRoutes(app, {
         engine,
         tasks: taskManager,
         getRouter: () => agentRouter,
+        getExecutor: () => taskExecutor,
+        skillsRegistry,
     });
     // Diagnostics routes
     registerDiagnosticsRoutes(app, {
@@ -420,7 +478,7 @@ async function startDaemon(options = {}) {
     });
     // 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);
+    registerA2aRoutes(app, store, daemonPkg.version, skillsRegistry);
     // 9. Initialize Registry integration (non-fatal — LAN must work without it)
     let identityKeys = null;
     let registryClient = null;
@@ -431,6 +489,8 @@ async function startDaemon(options = {}) {
     localProbe.on("local:discovered", (instance) => {
         app.log.info({ agent_id: instance.agent_id }, "Local OpenClaw instance discovered");
         broadcast.sendAnnounce();
+        // Start skills registry once we know the local Gateway is available
+        skillsRegistry.start();
     });
     localProbe.on("local:unavailable", () => {
         app.log.info("No local OpenClaw instance on :18789");
@@ -447,10 +507,12 @@ async function startDaemon(options = {}) {
             registryClient,
             identityKeys,
         });
+        let relayInitializing = false;
         autoRegister.on("registered", async (info) => {
             console.log(`[clawnexus] [Registry] Registered as ${info.claw_name} (${info.action})`);
-            // Initialize relay connector after successful registration
-            if (!connector && registryClient && info.claw_name) {
+            // Initialize relay connector after successful registration (once only)
+            if (!connector && !relayInitializing && registryClient && info.claw_name) {
+                relayInitializing = true;
                 try {
                     const tokenResult = await registryClient.getToken(info.claw_name);
                     console.log(`[clawnexus] [Relay] Got auth token, relay_hint: ${tokenResult.relay_hint}`);
@@ -478,7 +540,8 @@ async function startDaemon(options = {}) {
                     });
                     newConnector.connect();
                     setConnector(newConnector);
-                    // Start token refresh — every 4 minutes (token expires in 5 min)
+                    // Start token refresh — every 55 minutes (relay keeps WebSocket alive after auth,
+                    // only need to refresh for reconnection scenarios)
                     if (tokenRefreshTimer)
                         clearInterval(tokenRefreshTimer);
                     tokenRefreshTimer = setInterval(async () => {
@@ -486,8 +549,16 @@ async function startDaemon(options = {}) {
                             return;
                         try {
                             const fresh = await registryClient.getToken(autoRegister.clawName);
-                            // Reconnect with fresh token
-                            connector?.disconnect();
+                            // Save peer claw_ids from existing rooms before reconnecting
+                            const previousPeers = [];
+                            const oldConnector = connector;
+                            if (oldConnector) {
+                                for (const room of oldConnector.getStatus().rooms) {
+                                    if (room.peer_claw_id)
+                                        previousPeers.push(room.peer_claw_id);
+                                }
+                            }
+                            // Connect new first, then disconnect old (relay server handles replacement)
                             const refreshed = new connector_js_1.RelayConnector({
                                 relayUrl: process.env.CLAWNEXUS_RELAY_URL ?? `wss://${fresh.relay_hint}/relay`,
                                 clawId: autoRegister.clawName,
@@ -496,6 +567,15 @@ async function startDaemon(options = {}) {
                             });
                             refreshed.on("registered", (clawId) => {
                                 console.log(`[clawnexus] [Relay] Reconnected (token refresh) as ${clawId}`);
+                                // Old connector is now replaced on server side — disconnect it locally
+                                if (oldConnector && oldConnector !== refreshed) {
+                                    oldConnector.disconnect();
+                                }
+                                // Re-join rooms with previous peers
+                                for (const peerId of previousPeers) {
+                                    console.log(`[clawnexus] [Relay] Re-joining peer ${peerId} after token refresh`);
+                                    refreshed.join(peerId);
+                                }
                             });
                             refreshed.on("relay_error", (code, message) => {
                                 console.log(`[clawnexus] [Relay] Error: ${code} — ${message}`);
@@ -506,7 +586,7 @@ async function startDaemon(options = {}) {
                         catch (err) {
                             console.log(`[clawnexus] [Relay] Token refresh failed (non-fatal): ${err}`);
                         }
-                    }, 4 * 60 * 1000);
+                    }, 55 * 60 * 1000);
                 }
                 catch (err) {
                     console.log(`[clawnexus] [Relay] Failed to initialize (non-fatal): ${err}`);
@@ -552,6 +632,8 @@ async function startDaemon(options = {}) {
     app.addHook("onClose", async () => {
         if (tokenRefreshTimer)
             clearInterval(tokenRefreshTimer);
+        skillsRegistry.stop();
+        await taskExecutor.close();
         autoRegister?.stop();
         agentRouter?.stop();
         taskManager.close();
@@ -563,6 +645,8 @@ async function startDaemon(options = {}) {
         await store.close();
     });
     await app.listen({ port, host });
+    // Start task executor (independent of relay — connects to local OpenClaw Gateway)
+    taskExecutor.start();
     const setConnector = (c) => {
         connector = c;
         // When relay connector is set, create and start AgentRouter
@@ -572,9 +656,17 @@ async function startDaemon(options = {}) {
                 engine,
                 tasks: taskManager,
                 localClawId: c.getStatus().claw_id ?? "",
+                skillsRegistry,
             });
             agentRouter.start();
             app.log.info("Layer B agent router started");
+            // Give executor the router reference so it can send reports
+            taskExecutor.setRouter(agentRouter);
+        }
+        else {
+            // Update existing router with new connector (e.g. after token refresh)
+            agentRouter.setConnector(c);
+            app.log.info("Layer B agent router connector updated");
         }
     };
     return {
@@ -590,6 +682,7 @@ async function startDaemon(options = {}) {
         engine,
         tasks: taskManager,
         getRouter: () => agentRouter,
+        skillsRegistry,
         registryClient,
         autoRegister,
         remoteDiscovery,

package/dist/registry/auto-register.js

@@ -59,25 +59,38 @@ class AutoRegister extends node_events_1.EventEmitter {
             this.emit("skip", "No local OpenClaw instance detected");
             return;
         }
-        // Try agentId, then agentId-2, agentId-3, ... if name already taken by another owner
+        // Build list of base names to try: agentId first, then auto_name as fallback
+        const selfInstance = this.store.getAll().find((i) => i.is_self);
+        const autoName = selfInstance?.auto_name;
+        const bases = [agentId];
+        if (autoName && autoName !== agentId)
+            bases.push(autoName);
+        // Try each base with suffixes -1, -2, ... up to MAX_SUFFIX if taken by another owner
         const MAX_SUFFIX = 10;
         let result = null;
-        for (let i = 0; i <= MAX_SUFFIX; i++) {
-            const clawId = i === 0 ? agentId : `${agentId}-${i}`;
-            try {
-                result = await this.client.register({ claw_id: clawId });
-                break;
-            }
-            catch (err) {
-                if (err instanceof client_js_1.RegistryError && err.statusCode === 409 && i < MAX_SUFFIX) {
-                    continue; // name taken by another owner, try next suffix
+        outer: for (const base of bases) {
+            for (let i = 0; i <= MAX_SUFFIX; i++) {
+                const clawId = i === 0 ? base : `${base}-${i}`;
+                try {
+                    result = await this.client.register({ claw_id: clawId });
+                    break outer;
+                }
+                catch (err) {
+                    if (err instanceof client_js_1.RegistryError && err.statusCode === 409 && i < MAX_SUFFIX) {
+                        continue; // name taken by another owner, try next suffix
+                    }
+                    if (err instanceof client_js_1.RegistryError && err.statusCode === 409 && i === MAX_SUFFIX) {
+                        break; // exhausted suffixes for this base, try next base
+                    }
+                    this.emit("error", err);
+                    return;
                 }
-                this.emit("error", err);
-                return;
             }
         }
-        if (!result)
+        if (!result) {
+            this.emit("error", new Error(`All candidate names exhausted (bases: ${bases.join(", ")})`));
             return;
+        }
         this.registeredClawName = result.record.name;
         // Start heartbeat on first successful registration
         if (!this.heartbeatTimer) {
@@ -85,13 +98,12 @@ class AutoRegister extends node_events_1.EventEmitter {
                 this.tryRegister().catch(() => { });
             }, HEARTBEAT_INTERVAL_MS);
         }
-        // Write claw_name back to the local instance in store
-        const instances = this.store.getAll();
-        const selfInstance = instances.find((i) => i.is_self && i.agent_id === agentId);
-        if (selfInstance) {
-            selfInstance.claw_name = result.record.name;
-            selfInstance.owner_pubkey = result.record.ownerPubkey;
-            this.store.upsert(selfInstance);
+        // Write claw_name back to the local instance in store (re-fetch after possible state change)
+        const registeredSelf = this.store.getAll().find((i) => i.is_self && i.agent_id === agentId);
+        if (registeredSelf) {
+            registeredSelf.claw_name = result.record.name;
+            registeredSelf.owner_pubkey = result.record.ownerPubkey;
+            this.store.upsert(registeredSelf);
         }
         this.emit("registered", {
             action: result.action,

package/dist/relay/connector.d.ts

@@ -8,7 +8,7 @@ export interface RelayConnectorOptions {
     autoAccept?: boolean;
 }
 export declare class RelayConnector extends EventEmitter {
-    private readonly options;
+    private options;
     private ws;
     private state;
     private rooms;
@@ -17,10 +17,14 @@ export declare class RelayConnector extends EventEmitter {
     private reconnectTimer;
     private closed;
     constructor(options: RelayConnectorOptions);
+    /** Update the auth token (e.g. after token refresh). */
+    updateAuthToken(token: string): void;
     /** Connect to the relay and REGISTER this claw_id. */
     connect(): void;
     /** Disconnect and stop reconnecting. */
     disconnect(): void;
+    private pendingJoins;
+    private lastJoinTarget;
     /** Initiate a connection to a remote claw_id through the relay. */
     join(targetClawId: string): void;
     /** Send an encrypted message to a peer in a room. */

package/dist/relay/connector.js

@@ -20,6 +20,10 @@ class RelayConnector extends node_events_1.EventEmitter {
         this.options = options;
         this.keyPair = (0, crypto_js_1.generateKeyPair)();
     }
+    /** Update the auth token (e.g. after token refresh). */
+    updateAuthToken(token) {
+        this.options = { ...this.options, authToken: token };
+    }
     /** Connect to the relay and REGISTER this claw_id. */
     connect() {
         if (this.state !== "disconnected")
@@ -66,8 +70,12 @@ class RelayConnector extends node_events_1.EventEmitter {
         this.ws?.close();
         this.cleanup();
     }
+    // Tracks target claw_id for pending JOIN requests
+    pendingJoins = new Map(); // target_claw_id → target_claw_id (for JOINED room_id lookup)
+    lastJoinTarget = null;
     /** Initiate a connection to a remote claw_id through the relay. */
     join(targetClawId) {
+        this.lastJoinTarget = targetClawId;
         this.send({
             type: "JOIN",
             claw_id: this.options.clawId,
@@ -78,8 +86,10 @@ class RelayConnector extends node_events_1.EventEmitter {
     /** Send an encrypted message to a peer in a room. */
     sendData(roomId, plaintext) {
         const room = this.rooms.get(roomId);
-        if (!room || !room.session_key)
+        if (!room || !room.session_key) {
+            console.log(`[clawnexus] [Relay] sendData failed: room=${roomId} exists=${!!room} hasKey=${!!room?.session_key}`);
             return false;
+        }
         const payload = (0, crypto_js_1.encrypt)(room.session_key, plaintext);
         this.send({ type: "DATA", room_id: roomId, payload });
         return true;
@@ -98,6 +108,7 @@ class RelayConnector extends node_events_1.EventEmitter {
                 room_id: r.room_id,
                 peer_claw_id: r.peer_claw_id,
                 state: r.state,
+                has_session_key: !!r.session_key,
             })),
         };
     }
@@ -139,7 +150,7 @@ class RelayConnector extends node_events_1.EventEmitter {
                     // We are the initiator — create room entry
                     this.rooms.set(msg.room_id, {
                         room_id: msg.room_id,
-                        peer_claw_id: "", // will be known after key exchange
+                        peer_claw_id: this.lastJoinTarget ?? "",
                         state: "active",
                     });
                     // Send our public key

package/package.json

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