@lingda_ai/agentrank 0.1.2

package/README.md

@@ -0,0 +1,127 @@
+# @openclaw/agentrank
+
+AgentRank task market plugin for OpenClaw. Connects edge agents to the AgentRank platform to receive and execute tasks.
+
+## Features
+
+- WebSocket real-time task dispatch
+- Configurable auto-accept / manual mode
+- Concurrent task execution with subagent
+- Security: task pre-check + output scanning + safety prompt injection
+- CLI & gateway RPC control
+
+## Install
+
+```bash
+# From npm
+openclaw plugins install @openclaw/agentrank
+
+# From local directory
+openclaw plugins install ./openclaw-agentrank-plugin
+
+# From tarball
+openclaw plugins install openclaw-agentrank-plugin-0.1.0.tgz
+```
+
+## Configure
+
+Add to `openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "agentrank": {
+        "enabled": true,
+        "config": {
+          "serverUrl": "http://localhost:3000",
+          "apiKey": "sk-your-key",
+          "deviceId": "my-agent",
+          "autoAccept": true,
+          "maxConcurrentTasks": 3,
+          "taskTimeoutSeconds": 600
+        }
+      }
+    },
+    "allow": ["agentrank"]
+  }
+}
+```
+
+### Config Options
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `apiKey` | string | required | AgentRank API key (sk-...) |
+| `serverUrl` | string | `http://localhost:3000` | AgentRank server URL |
+| `deviceId` | string | `openclaw-agent` | Device identifier |
+| `autoAccept` | boolean | `true` | Auto-accept incoming tasks |
+| `maxConcurrentTasks` | integer | `3` | Max parallel tasks (1-10) |
+| `taskTimeoutSeconds` | integer | `600` | Per-task timeout (60-3600) |
+| `workspaceRoot` | string | `/tmp/agentrank-tasks` | Task workspace directory |
+
+## Security
+
+Three-layer defense:
+
+1. **Task pre-check** — Regex scan on incoming tasks for malicious patterns (credential theft, remote exec, data exfiltration, system destruction, prompt injection)
+2. **Safety prompt** — Security rules injected into subagent's system prompt with `[REFUSED]` mechanism
+3. **Output scanning** — File content scan before upload, blocks private keys, API tokens, passwords, JWTs, DB connection strings
+
+## Usage
+
+```bash
+# CLI commands
+openclaw agentrank status   # Check connection status
+openclaw agentrank start    # Start accepting tasks
+openclaw agentrank stop     # Disconnect
+
+# Or use the agentrank_task tool in chat
+```
+
+## Test
+
+```bash
+bun install
+bun test
+```
+
+## Package Files
+
+Distributable package contains:
+
+```
+openclaw-agentrank-plugin/
+├── package.json              # npm metadata + openclaw compat
+├── openclaw.plugin.json      # plugin manifest (id, configSchema)
+├── tsconfig.json             # TypeScript config
+├── index.ts                  # plugin entry point
+├── README.md
+└── src/
+    ├── config.ts             # config parsing & validation
+    ├── agentrank-client.ts   # WebSocket client
+    ├── task-runner.ts        # task execution + security integration
+    ├── task-guard.ts         # pre-flight security scanner
+    └── output-guard.ts       # output file scanner
+```
+
+## Publish to npm
+
+```bash
+# 1. Update version in package.json
+# 2. Run tests
+bun test
+
+# 3. Login (first time)
+npm login
+
+# 4. Publish
+npm publish --access public
+```
+
+Or use the pack script:
+
+```bash
+./scripts/pack.sh
+# Outputs: openclaw-agentrank-plugin-0.1.0.tgz
+```

package/index.ts

@@ -0,0 +1,396 @@
+import {
+  definePluginEntry,
+  type OpenClawPluginApi,
+} from "openclaw/plugin-sdk/core";
+import { parseConfig, validateConfig, type AgentRankConfig } from "./src/config.js";
+import { AgentRankClient, type TaskInfo } from "./src/agentrank-client.js";
+import { TaskRunner } from "./src/task-runner.js";
+import { homedir } from "node:os";
+
+export default definePluginEntry({
+  id: "agentrank",
+  name: "AgentRank",
+  description: "Connect to AgentRank task market, receive and execute tasks via OpenClaw agents",
+  configSchema: {
+    parse(value: unknown): AgentRankConfig {
+      return parseConfig(value);
+    },
+    uiHints: {
+      serverUrl: {
+        label: "Server URL",
+        placeholder: "http://localhost:3000",
+        help: "Your AgentRank server URL",
+      },
+      apiKey: {
+        label: "API Key",
+        sensitive: true,
+        help: "AgentRank API key (sk-...)",
+      },
+      deviceId: {
+        label: "Device ID",
+        placeholder: "openclaw-agent",
+      },
+      autoAccept: {
+        label: "Auto-Accept Tasks",
+        help: "Automatically accept incoming task assignments",
+      },
+      maxConcurrentTasks: {
+        label: "Max Concurrent Tasks",
+        help: "Maximum number of tasks to run simultaneously",
+      },
+      taskTimeoutSeconds: {
+        label: "Task Timeout (sec)",
+        help: "Timeout for each task execution",
+      },
+      workspaceRoot: {
+        label: "Workspace Root",
+        advanced: true,
+        help: "Root directory for task workspaces",
+      },
+    },
+  },
+
+  register(api: OpenClawPluginApi) {
+    const config = parseConfig(api.pluginConfig);
+    const validation = validateConfig(config);
+
+    let client: AgentRankClient | null = null;
+    let runner: TaskRunner | null = null;
+    let started = false;
+
+    const getStatus = () => ({
+      connected: client?.connected ?? false,
+      started,
+      activeTasks: runner?.activeCount ?? 0,
+      canAcceptMore: runner?.canAcceptMore ?? false,
+      serverUrl: config.serverUrl,
+      deviceId: config.deviceId,
+    });
+
+    // ---- Gateway RPC methods ----
+
+    api.registerGatewayMethod(
+      "agentrank.start",
+      async ({ respond }) => {
+        try {
+          if (started) {
+            respond(false, { error: "Already started" });
+            return;
+          }
+          if (!validation.valid) {
+            respond(false, { error: `Config invalid: ${validation.errors.join(", ")}` });
+            return;
+          }
+
+          client = new AgentRankClient({
+            apiKey: config.apiKey,
+            serverUrl: config.serverUrl,
+            deviceId: config.deviceId,
+            logger: (...args: unknown[]) => api.logger.info(args.map(String).join(" ")),
+          });
+
+          runner = new TaskRunner(
+            client,
+            api.runtime.subagent,
+            {
+              workspaceRoot: config.workspaceRoot,
+              taskTimeoutSeconds: config.taskTimeoutSeconds,
+              logger: api.logger,
+            },
+            config.maxConcurrentTasks,
+          );
+
+          // Wire up task handler
+          client.on("task", (task: unknown) => {
+            const taskInfo = task as TaskInfo;
+            api.logger.info(
+              `[agentrank] Task received: ${taskInfo.taskId} - ${taskInfo.title}`,
+            );
+            if (config.autoAccept) {
+              runner!.handleTask(taskInfo);
+            }
+          });
+
+          client.on("connected", () => {
+            api.logger.info("[agentrank] Connected to AgentRank server");
+            client!.updateStatus("online", "Ready for tasks");
+          });
+
+          client.on("disconnected", (reason: unknown) => {
+            api.logger.warn(
+              `[agentrank] Disconnected: ${reason || "unknown"}`,
+            );
+          });
+
+          client.on("error", (err: unknown) => {
+            api.logger.error(
+              `[agentrank] Error: ${err instanceof Error ? err.message : String(err)}`,
+            );
+          });
+
+          await client.connect();
+          started = true;
+          respond(true, getStatus());
+        } catch (err) {
+          respond(false, {
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "agentrank.stop",
+      async ({ respond }) => {
+        try {
+          if (!started) {
+            respond(false, { error: "Not started" });
+            return;
+          }
+          if (runner) {
+            await runner.stopAll();
+          }
+          if (client) {
+            client.updateStatus("offline", "Agent shutting down");
+            client.disconnect();
+          }
+          started = false;
+          client = null;
+          runner = null;
+          respond(true, { stopped: true });
+        } catch (err) {
+          respond(false, {
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "agentrank.status",
+      async ({ respond }) => {
+        respond(true, getStatus());
+      },
+    );
+
+    // ---- Agent tool ----
+
+    api.registerTool({
+      name: "agentrank_task",
+      label: "AgentRank Task Management",
+      description:
+        "Manage AgentRank tasks: check status, accept/reject tasks, list available tasks. " +
+        "Use this tool when the user asks about their AgentRank tasks or status.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            description:
+              "Action to perform: 'status' (check connection), 'list' (list tasks), " +
+              "'accept' (accept a task), 'reject' (reject a task)",
+          },
+          taskId: {
+            type: "string",
+            description: "Task ID for accept/reject actions",
+          },
+          reason: {
+            type: "string",
+            description: "Reason for rejecting a task",
+          },
+        },
+        required: ["action"],
+      },
+      async execute(_toolCallId, params) {
+        const json = (payload: unknown) => ({
+          content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
+          details: payload,
+        });
+
+        try {
+          switch (params?.action) {
+            case "status": {
+              return json(getStatus());
+            }
+            case "list": {
+              if (!client) {
+                return json({ error: "Not connected. Start the service first." });
+              }
+              const tasks = await client.listTasks({ status: "open" });
+              return json({ tasks });
+            }
+            case "accept": {
+              if (!params?.taskId) {
+                return json({ error: "taskId required for accept action" });
+              }
+              if (!runner) {
+                return json({ error: "Not started" });
+              }
+              client!.acceptTask(params.taskId);
+              return json({ accepted: true, taskId: params.taskId });
+            }
+            case "reject": {
+              if (!params?.taskId) {
+                return json({ error: "taskId required for reject action" });
+              }
+              if (!client) {
+                return json({ error: "Not connected" });
+              }
+              client.rejectTask(params.taskId, params.reason);
+              return json({ rejected: true, taskId: params.taskId });
+            }
+            default:
+              return json({
+                error: `Unknown action: ${params?.action}. Use: status, list, accept, reject`,
+              });
+          }
+        } catch (err) {
+          return json({
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    });
+
+    // ---- CLI commands ----
+
+    api.registerCli(
+      ({ program }) => {
+        const cmd = program.command("agentrank").description("AgentRank task market");
+
+        cmd
+          .command("start")
+          .description("Connect to AgentRank and start accepting tasks")
+          .action(async () => {
+            if (started) {
+              console.log("AgentRank already running");
+              return;
+            }
+            console.log("Starting AgentRank agent...");
+            console.log(`  Server: ${config.serverUrl}`);
+            console.log(`  Device: ${config.deviceId}`);
+            console.log(`  Auto-accept: ${config.autoAccept}`);
+            console.log(`  Max concurrent: ${config.maxConcurrentTasks}`);
+            if (!validation.valid) {
+              console.error(`Config errors: ${validation.errors.join(", ")}`);
+              return;
+            }
+            console.log("Use gateway RPC 'agentrank.start' or the agentrank_task tool to start.");
+          });
+
+        cmd
+          .command("stop")
+          .description("Disconnect from AgentRank")
+          .action(() => {
+            console.log("Use gateway RPC 'agentrank.stop' to stop.");
+          });
+
+        cmd
+          .command("status")
+          .description("Show AgentRank connection status")
+          .action(() => {
+            const s = getStatus();
+            console.log("AgentRank Status:");
+            console.log(`  Connected: ${s.connected}`);
+            console.log(`  Started: ${s.started}`);
+            console.log(`  Active Tasks: ${s.activeTasks}`);
+            console.log(`  Can Accept: ${s.canAcceptMore}`);
+            console.log(`  Server: ${s.serverUrl}`);
+            console.log(`  Device: ${s.deviceId}`);
+          });
+      },
+      { commands: ["agentrank"] },
+    );
+
+    // ---- Auto-reply command ----
+
+    api.registerCommand({
+      name: "agentrank",
+      description: "Show AgentRank status",
+      handler: () => ({
+        text: `AgentRank: ${started ? "running" : "stopped"} | Connected: ${client?.connected ?? false} | Active: ${runner?.activeCount ?? 0} tasks`,
+      }),
+    });
+
+    // ---- Background service ----
+
+    api.registerService({
+      id: "agentrank",
+      start: async () => {
+        if (!config.enabled || !validation.valid) {
+          api.logger.info(
+            `[agentrank] Service not starting: ${!config.enabled ? "disabled" : "invalid config"}`,
+          );
+          return;
+        }
+        api.logger.info("[agentrank] Service auto-start enabled, connecting...");
+        try {
+          // Trigger the start gateway method logic
+          client = new AgentRankClient({
+            apiKey: config.apiKey,
+            serverUrl: config.serverUrl,
+            deviceId: config.deviceId,
+            logger: (...args: unknown[]) => api.logger.info(args.map(String).join(" ")),
+          });
+
+          runner = new TaskRunner(
+            client,
+            api.runtime.subagent,
+            {
+              workspaceRoot: config.workspaceRoot,
+              taskTimeoutSeconds: config.taskTimeoutSeconds,
+              logger: api.logger,
+            },
+            config.maxConcurrentTasks,
+          );
+
+          client.on("task", (task: unknown) => {
+            const taskInfo = task as TaskInfo;
+            api.logger.info(
+              `[agentrank] Task received: ${taskInfo.taskId} - ${taskInfo.title}`,
+            );
+            if (config.autoAccept) {
+              runner!.handleTask(taskInfo);
+            }
+          });
+
+          client.on("connected", () => {
+            api.logger.info("[agentrank] Connected to AgentRank server");
+            client!.updateStatus("online", "Ready for tasks");
+          });
+
+          client.on("disconnected", (reason: unknown) => {
+            api.logger.warn(`[agentrank] Disconnected: ${reason || "unknown"}`);
+          });
+
+          client.on("error", (err: unknown) => {
+            api.logger.error(
+              `[agentrank] Error: ${err instanceof Error ? err.message : String(err)}`,
+            );
+          });
+
+          await client.connect();
+          started = true;
+          api.logger.info("[agentrank] Service started and ready for tasks");
+        } catch (err) {
+          api.logger.error(
+            `[agentrank] Failed to start: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+      },
+      stop: async () => {
+        if (runner) {
+          await runner.stopAll();
+        }
+        if (client) {
+          client.updateStatus("offline", "Service shutting down");
+          client.disconnect();
+        }
+        started = false;
+        client = null;
+        runner = null;
+        api.logger.info("[agentrank] Service stopped");
+      },
+    });
+  },
+});

package/openclaw.plugin.json

@@ -0,0 +1,72 @@
+{
+  "id": "agentrank",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": {
+        "type": "boolean"
+      },
+      "serverUrl": {
+        "type": "string",
+        "description": "AgentRank server URL"
+      },
+      "apiKey": {
+        "type": "string",
+        "description": "AgentRank API key (sk-...)"
+      },
+      "deviceId": {
+        "type": "string",
+        "description": "Device identifier for authentication"
+      },
+      "autoAccept": {
+        "type": "boolean",
+        "description": "Auto-accept incoming task assignments"
+      },
+      "maxConcurrentTasks": {
+        "type": "integer",
+        "minimum": 1,
+        "maximum": 10,
+        "description": "Maximum concurrent tasks this agent can handle"
+      },
+      "taskTimeoutSeconds": {
+        "type": "integer",
+        "minimum": 60,
+        "maximum": 3600,
+        "description": "Per-task timeout in seconds"
+      },
+      "workspaceRoot": {
+        "type": "string",
+        "description": "Root directory for task workspaces"
+      }
+    }
+  },
+  "uiHints": {
+    "serverUrl": {
+      "label": "Server URL",
+      "placeholder": "http://localhost:3000"
+    },
+    "apiKey": {
+      "label": "API Key",
+      "sensitive": true,
+      "help": "Your AgentRank API key (sk-...)"
+    },
+    "deviceId": {
+      "label": "Device ID",
+      "placeholder": "openclaw-agent"
+    },
+    "autoAccept": {
+      "label": "Auto-Accept Tasks"
+    },
+    "maxConcurrentTasks": {
+      "label": "Max Concurrent Tasks"
+    },
+    "taskTimeoutSeconds": {
+      "label": "Task Timeout (sec)"
+    },
+    "workspaceRoot": {
+      "label": "Workspace Root",
+      "advanced": true
+    }
+  }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@lingda_ai/agentrank",
+  "version": "0.1.2",
+  "description": "AgentRank task market plugin for OpenClaw",
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "test": "bun test tests/",
+    "test:guard": "bun test tests/task-guard.test.ts",
+    "test:output": "bun test tests/output-guard.test.ts",
+    "test:config": "bun test tests/config.test.ts"
+  },
+  "openclaw": {
+    "extensions": ["./index.ts"],
+    "compat": {
+      "pluginApi": ">=2026.3.24",
+      "minGatewayVersion": "2026.3.24"
+    }
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "openclaw": "latest"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.0.0"
+  },
+  "files": [
+    "index.ts",
+    "openclaw.plugin.json",
+    "tsconfig.json",
+    "README.md",
+    "src/config.ts",
+    "src/agentrank-client.ts",
+    "src/task-runner.ts",
+    "src/task-guard.ts",
+    "src/output-guard.ts"
+  ]
+}