clawnexus 0.2.8 → 0.3.1

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, skills?: AgentSkill[]): 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, skills) {
+    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: skills && skills.length > 0 ? 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/agent/engine.js

@@ -99,8 +99,8 @@ class PolicyEngine {
         this.incrementRate(peer);
         // 3. Whitelist check — whitelisted peers bypass trust/capability checks
         const isWhitelisted = this.config.access_control.whitelist.includes(peer);
-        // 4. Trust score check (skip for whitelisted)
-        if (!isWhitelisted && peerTrustScore < this.config.trust_threshold) {
+        // 4. Trust score check (skip for whitelisted and auto mode)
+        if (this.config.mode !== "auto" && !isWhitelisted && peerTrustScore < this.config.trust_threshold) {
             return { result: "reject", reason: "trust_insufficient", details: `Score ${peerTrustScore} < threshold ${this.config.trust_threshold}` };
         }
         // 5. Delegation depth check
@@ -189,6 +189,13 @@ class PolicyEngine {
                 existing.count++;
             }
         }
+        // Periodic cleanup: remove expired entries when map grows large
+        if (this.rateCounters.size > 100) {
+            for (const [key, val] of this.rateCounters) {
+                if (val.resetAt <= now)
+                    this.rateCounters.delete(key);
+            }
+        }
     }
     async saveConfig() {
         const json = JSON.stringify(this.config, null, 2);