@lingda_ai/agentrank 0.1.2

package/src/task-runner.ts

@@ -0,0 +1,564 @@
+import type { AgentRankClient, TaskInfo, SubmitResult } from "./agentrank-client.js";
+import type { PluginRuntime } from "openclaw/plugin-sdk/core";
+import { mkdir, writeFile, readdir, readFile, rm } from "node:fs/promises";
+import { join, extname } from "node:path";
+import { homedir } from "node:os";
+import { checkTask as guardCheckTask } from "./task-guard.js";
+import { scanFileContent } from "./output-guard.js";
+
+export interface TaskRunnerOptions {
+  workspaceRoot: string;
+  taskTimeoutSeconds: number;
+  logger: PluginRuntime["logger"];
+}
+
+interface ActiveTask {
+  taskId: string;
+  startTime: number;
+  controller: AbortController;
+}
+
+/**
+ * TaskRunner manages the lifecycle of individual tasks.
+ * For each task, it:
+ * 1. Creates an isolated workspace
+ * 2. Runs the task via OpenClaw's subagent runtime
+ * 3. Reports progress and submits results back to AgentRank
+ */
+export class TaskRunner {
+  private client: AgentRankClient;
+  private options: TaskRunnerOptions;
+  private activeTasks = new Map<string, ActiveTask>();
+  private maxConcurrent: number;
+  private subagent: PluginRuntime["subagent"];
+
+  constructor(
+    client: AgentRankClient,
+    subagent: PluginRuntime["subagent"],
+    options: TaskRunnerOptions,
+    maxConcurrent: number,
+  ) {
+    this.client = client;
+    this.subagent = subagent;
+    this.options = options;
+    this.maxConcurrent = maxConcurrent;
+
+    // Listen for task cancellation
+    this.client.on("cancel", (taskId: unknown, reason: unknown) => {
+      this.cancelTask(taskId as string, reason as string);
+    });
+  }
+
+  get activeCount() {
+    return this.activeTasks.size;
+  }
+
+  get canAcceptMore() {
+    return this.activeTasks.size < this.maxConcurrent;
+  }
+
+  /** Handle a new task assignment */
+  async handleTask(task: TaskInfo): Promise<boolean> {
+    if (!this.canAcceptMore) {
+      this.options.logger.warn(
+        `[agentrank] Task ${task.taskId} rejected: max concurrent tasks reached (${this.maxConcurrent})`,
+      );
+      this.client.rejectTask(task.taskId, "Agent at capacity");
+      return false;
+    }
+
+    // Security pre-check: scan task for malicious patterns
+    const guardResult = guardCheckTask(task);
+    if (!guardResult.safe) {
+      this.options.logger.warn(
+        `[agentrank][guard] Task ${task.taskId} BLOCKED: ${guardResult.reasons.join(", ")}`,
+      );
+      this.client.rejectTask(task.taskId, `Blocked by safety guard: ${guardResult.reasons.join("; ")}`);
+      return false;
+    }
+
+    // Accept the task
+    this.client.acceptTask(task.taskId);
+
+    // Set up workspace
+    const workspaceDir = join(
+      this.options.workspaceRoot.replace("~", homedir()),
+      task.taskId,
+    );
+    await mkdir(workspaceDir, { recursive: true });
+
+    // Write task context to workspace
+    const taskContext = {
+      taskId: task.taskId,
+      title: task.title,
+      description: task.description,
+      category: task.category,
+      price: task.price,
+      deadline: task.deadline,
+      inputData: task.inputData,
+      workspaceDir,
+    };
+    await writeFile(
+      join(workspaceDir, "task.json"),
+      JSON.stringify(taskContext, null, 2),
+    );
+
+    // Track the task
+    const controller = new AbortController();
+    this.activeTasks.set(task.taskId, {
+      taskId: task.taskId,
+      startTime: Date.now(),
+      controller,
+    });
+
+    // Report status busy
+    this.client.updateStatus("busy", `Working on task: ${task.title}`);
+
+    // Start task execution in background
+    this.executeTask(task, workspaceDir, controller.signal).catch((err) => {
+      this.options.logger.error(
+        `[agentrank] Task ${task.taskId} execution failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    });
+
+    return true;
+  }
+
+  /** Execute a task using OpenClaw's subagent runtime */
+  private async executeTask(
+    task: TaskInfo,
+    workspaceDir: string,
+    signal: AbortSignal,
+  ): Promise<void> {
+    const timeoutMs = this.options.taskTimeoutSeconds * 1000;
+    if (!this.activeTasks.has(task.taskId)) return;
+
+    try {
+      // Report progress: starting
+      this.client.updateProgress(task.taskId, {
+        percent: 5,
+        message: "Starting task execution",
+        stage: "initializing",
+      });
+
+      // Build the prompt for the subagent
+      const taskMessage = this.buildTaskMessage(task, workspaceDir);
+
+      // Use subagent runtime: run -> wait -> get messages
+      const sessionKey = `agentrank:${task.taskId}`;
+
+      this.client.updateProgress(task.taskId, {
+        percent: 20,
+        message: "Dispatching to subagent",
+        stage: "running",
+      });
+
+      const { runId } = await this.subagent.run({
+        sessionKey,
+        message: taskMessage,
+        extraSystemPrompt: this.buildSafetyPrompt(workspaceDir),
+        idempotencyKey: `agentrank-${task.taskId}-${Date.now()}`,
+      });
+
+      if (signal.aborted) return;
+
+      // Wait for the run to complete, polling progress periodically
+      const waitResult = await this.runWithTimeout(
+        this.waitForRunWithProgress(runId, task.taskId, timeoutMs, signal),
+        timeoutMs,
+        signal,
+      );
+
+      if (signal.aborted) return;
+
+      if (waitResult.status === "error") {
+        throw new Error(waitResult.error || "Subagent run failed");
+      }
+
+      if (waitResult.status === "timeout") {
+        throw new Error("Subagent run timed out");
+      }
+
+      this.client.updateProgress(task.taskId, {
+        percent: 80,
+        message: "Reading subagent output",
+        stage: "finalizing",
+      });
+
+      // Get the session messages to extract the result
+      const { messages } = await this.subagent.getSessionMessages({
+        sessionKey,
+        limit: 10,
+      });
+
+      // Extract the last assistant message as the summary
+      const summary = this.extractSummary(messages);
+
+      // Check if subagent refused the task (safety rules)
+      if (summary.startsWith("[REFUSED]")) {
+        this.options.logger.warn(
+          `[agentrank] Task ${task.taskId} refused by subagent: ${summary}`,
+        );
+        this.client.failTask(task.taskId, summary, false);
+        return;
+      }
+
+      if (signal.aborted) return;
+
+      // Save result to workspace
+      await writeFile(
+        join(workspaceDir, "result.json"),
+        JSON.stringify({
+          taskId: task.taskId,
+          runId,
+          messages,
+          summary,
+          completedAt: new Date().toISOString(),
+        }, null, 2),
+      );
+
+      // Upload output files to AgentRank server
+      this.client.updateProgress(task.taskId, {
+        percent: 90,
+        message: "Uploading output files to server",
+        stage: "uploading",
+      });
+
+      const outputRefs = await this.uploadWorkspaceFiles(task.taskId, workspaceDir);
+
+      // Submit result to AgentRank
+      const submitResult: SubmitResult = {
+        summary: String(summary).slice(0, 5000),
+        outputRefs,
+      };
+
+      this.client.submitTask(task.taskId, submitResult);
+
+      // Clean up local workspace to protect task sender privacy
+      try {
+        await rm(workspaceDir, { recursive: true, force: true });
+      } catch {
+        // Non-critical: best-effort cleanup
+      }
+
+      this.options.logger.info(
+        `[agentrank] Task ${task.taskId} completed and workspace cleaned`,
+      );
+    } catch (err) {
+      if (signal.aborted) return;
+
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.options.logger.error(
+        `[agentrank] Task ${task.taskId} failed: ${errorMessage}`,
+      );
+
+      // Check if it's a timeout
+      const isTimeout = errorMessage.includes("timeout") || errorMessage.includes("Timeout");
+      this.client.failTask(task.taskId, errorMessage, isTimeout);
+    } finally {
+      this.activeTasks.delete(task.taskId);
+
+      // Always clean up workspace on failure too
+      try {
+        await rm(workspaceDir, { recursive: true, force: true });
+      } catch {
+        // Non-critical
+      }
+
+      // If no more active tasks, go back to online
+      if (this.activeTasks.size === 0) {
+        this.client.updateStatus("online", "Ready for tasks");
+      } else {
+        this.client.updateStatus("busy", `Working on ${this.activeTasks.size} task(s)`);
+      }
+    }
+  }
+
+  /** Extract a summary from subagent session messages */
+  private extractSummary(messages: unknown[]): string {
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return "Task completed (no output captured)";
+    }
+
+    // Find the last assistant message with text content
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i] as { role?: string; content?: string | Array<{ type?: string; text?: string }> };
+      if (msg.role === "assistant" && msg.content) {
+        if (typeof msg.content === "string") {
+          return msg.content;
+        }
+        if (Array.isArray(msg.content)) {
+          const textParts = msg.content
+            .filter((c): c is { type: string; text: string } => c.type === "text" && typeof c.text === "string")
+            .map((c) => c.text);
+          if (textParts.length > 0) return textParts.join("\n");
+        }
+      }
+    }
+
+    return "Task completed";
+  }
+
+  /** Cancel a running task */
+  cancelTask(taskId: string, reason: string) {
+    const activeTask = this.activeTasks.get(taskId);
+    if (activeTask) {
+      activeTask.controller.abort();
+      this.activeTasks.delete(taskId);
+      this.options.logger.info(`[agentrank] Task ${taskId} cancelled: ${reason}`);
+
+      if (this.activeTasks.size === 0) {
+        this.client.updateStatus("online", "Ready for tasks");
+      }
+    }
+  }
+
+  /** Scan workspace for output files and upload them to AgentRank server via HTTP */
+  private async uploadWorkspaceFiles(
+    taskId: string,
+    workspaceDir: string,
+  ): Promise<SubmitResult["outputRefs"]> {
+    const MIME_MAP: Record<string, string> = {
+      ".md": "text/markdown",
+      ".txt": "text/plain",
+      ".json": "application/json",
+      ".ts": "text/typescript",
+      ".js": "text/javascript",
+      ".py": "text/x-python",
+      ".csv": "text/csv",
+      ".html": "text/html",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".pdf": "application/pdf",
+    };
+
+    const entries = await readdir(workspaceDir);
+    // Skip task.json and result.json (internal metadata)
+    const outputFiles = entries.filter((f) => f !== "task.json" && f !== "result.json");
+
+    if (outputFiles.length === 0) return [];
+
+    const refs: SubmitResult["outputRefs"] = [];
+
+    for (const fileName of outputFiles) {
+      const filePath = join(workspaceDir, fileName);
+      try {
+        const content = await readFile(filePath);
+
+        // Security scan: check for sensitive data before uploading
+        const scan = scanFileContent(fileName, content);
+        if (!scan.safe) {
+          for (const finding of scan.findings) {
+            this.options.logger.warn(
+              `[agentrank][guard] Output BLOCKED: ${finding.label} in ${finding.file}`,
+            );
+          }
+          continue; // Skip this file, continue with others
+        }
+
+        const ext = extname(fileName).toLowerCase();
+        const mimeType = MIME_MAP[ext] || "application/octet-stream";
+
+        this.options.logger.info(
+          `[agentrank] Uploading file: ${fileName} (${content.length} bytes)`,
+        );
+
+        await this.client.uploadFile(taskId, fileName, Buffer.from(content));
+
+        refs.push({
+          name: fileName,
+          url: `/api/v1/tasks/${taskId}/files/${fileName}`,
+          mimeType,
+          size: content.length,
+        });
+
+        this.options.logger.info(
+          `[agentrank] Uploaded: ${fileName} → /api/v1/tasks/${taskId}/files/${fileName}`,
+        );
+      } catch (err) {
+        this.options.logger.error(
+          `[agentrank] Failed to upload ${fileName}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+
+    return refs;
+  }
+
+  /** Build the system prompt with safety rules for the subagent */
+  private buildSafetyPrompt(workspaceDir: string): string {
+    return [
+      `You are an AgentRank task executor running on a user's device. Working directory: ${workspaceDir}. Write output files there.`,
+      "",
+      "## Safety Rules (MUST follow)",
+      "",
+      "You have the RIGHT and OBLIGATION to refuse tasks that violate these rules. If you refuse, respond with:",
+      '"[REFUSED] <reason>" as the first line, then explain why.',
+      "",
+      "1. **No credential theft**: Do NOT read, access, or exfiltrate SSH keys, API keys, .env files,",
+      "   password managers, browser cookies, or any authentication secrets from this device.",
+      "   Paths like ~/.ssh/, ~/.aws/, ~/.gnupg/, .env, credentials.json are OFF LIMITS.",
+      "",
+      "2. **No system destruction**: Do NOT delete, modify, or encrypt system files, user data outside",
+      "   the workspace, or execute destructive commands (rm -rf /, format, dd, etc.).",
+      "",
+      "3. **No hidden payloads**: Do NOT download and execute unknown binaries, shell scripts from",
+      "   untrusted URLs, or obfuscated code. If the task asks you to run curl | bash or similar, REFUSE.",
+      "",
+      "4. **No network abuse**: Do NOT launch DDoS attacks, scan ports, brute-force login, or send spam.",
+      "   Normal web browsing and API calls for task completion are fine.",
+      "",
+      "5. **No surveillance**: Do NOT install keyloggers, screen capture tools, sniff network traffic,",
+      "   or collect information about the user's other activities beyond the task scope.",
+      "",
+      "6. **Stay in workspace**: Keep all file operations within the working directory unless the task",
+      "   legitimately requires accessing specific user-specified paths (e.g., reading a project folder).",
+      "",
+      "If a task seems suspicious, ambiguous, or you're unsure — REFUSE and explain why.",
+      "When in doubt, protect the user's device and data.",
+    ].join("\n");
+  }
+
+  /** Build the message sent to the subagent */
+  private buildTaskMessage(task: TaskInfo, workspaceDir: string): string {
+    const parts = [
+      `# AgentRank Task: ${task.title}`,
+      "",
+      `**Task ID**: ${task.taskId}`,
+      `**Category**: ${task.category}`,
+      task.deadline ? `**Deadline**: ${task.deadline}` : "",
+      "",
+      "## Description",
+      task.description,
+      "",
+    ];
+
+    if (task.inputData && Object.keys(task.inputData).length > 0) {
+      parts.push(
+        "## Input Data",
+        "```json",
+        JSON.stringify(task.inputData, null, 2),
+        "```",
+        "",
+      );
+    }
+
+    parts.push(
+      "## Instructions",
+      `Complete the task described above. Your working directory is: ${workspaceDir}`,
+      "Write any output files to the working directory.",
+      "Provide a clear summary of what you did and the results.",
+    );
+
+    return parts.filter(Boolean).join("\n");
+  }
+
+  /** Wait for a subagent run while polling for progress updates */
+  private async waitForRunWithProgress(
+    runId: string,
+    taskId: string,
+    timeoutMs: number,
+    signal: AbortSignal,
+  ): Promise<{ status: string; error?: string }> {
+    const pollIntervalMs = 15_000; // Poll every 15 seconds
+    const startTime = Date.now();
+    let lastPercent = 20;
+
+    // Start the actual wait in background
+    const waitPromise = this.subagent.waitForRun({ runId, timeoutMs });
+
+    // Poll progress while waiting
+    const pollTimer = setInterval(async () => {
+      if (signal.aborted) {
+        clearInterval(pollTimer);
+        return;
+      }
+
+      const elapsed = Date.now() - startTime;
+      const remaining = Math.max(0, timeoutMs - elapsed);
+      const elapsedPercent = Math.min(70, Math.floor((elapsed / timeoutMs) * 70));
+
+      if (elapsedPercent > lastPercent) {
+        lastPercent = elapsedPercent;
+        this.client.updateProgress(taskId, {
+          percent: 20 + elapsedPercent,
+          message: `Subagent running (${Math.floor(elapsed / 1000)}s elapsed, ${Math.floor(remaining / 1000)}s remaining)`,
+          stage: "running",
+        });
+      }
+
+      // Try to get session messages to see latest activity
+      try {
+        const { messages } = await this.subagent.getSessionMessages({
+          sessionKey: `agentrank:${taskId}`,
+          limit: 3,
+        });
+        const lastMsg = this.extractSummary(messages);
+        if (lastMsg && lastMsg !== "Task completed") {
+          const snippet = lastMsg.slice(0, 100).replace(/\n/g, " ");
+          this.options.logger.info(
+            `[agentrank] Subagent progress for ${taskId}: ${snippet}...`,
+          );
+        }
+      } catch {
+        // Ignore polling errors
+      }
+    }, pollIntervalMs);
+
+    try {
+      const result = await waitPromise;
+      clearInterval(pollTimer);
+      return result;
+    } catch (err) {
+      clearInterval(pollTimer);
+      throw err;
+    }
+  }
+
+  /** Run a promise with timeout and abort signal support */
+  private runWithTimeout<T>(
+    promise: Promise<T>,
+    timeoutMs: number,
+    signal: AbortSignal,
+  ): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Task timed out after ${timeoutMs / 1000}s`));
+      }, timeoutMs);
+
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new Error("Task cancelled"));
+      };
+
+      if (signal.aborted) {
+        clearTimeout(timer);
+        reject(new Error("Task cancelled"));
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+
+      promise
+        .then((result) => {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", onAbort);
+          resolve(result);
+        })
+        .catch((err) => {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", onAbort);
+          reject(err);
+        });
+    });
+  }
+
+  /** Stop all active tasks */
+  async stopAll() {
+    for (const [taskId, activeTask] of this.activeTasks) {
+      activeTask.controller.abort();
+      this.client.failTask(taskId, "Agent shutting down", true);
+    }
+    this.activeTasks.clear();
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "declaration": true,
+    "sourceMap": true,
+    "types": ["bun-types"]
+  },
+  "include": ["index.ts", "src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}