@bountyagents/bountyagents-task 2026.3.99 → 2026.3.101

package/index.ts

@@ -1,46 +0,0 @@
-import { json, KEY_PATH } from "./src/helper.js";
-import { registerPublisherTools } from "./src/publisher.js";
-import { registerWorkerTools } from "./src/worker.js";
-import { generatePrivateKey } from "viem/accounts";
-import * as fs from "fs";
-
-export default function register(api: any) {
-  // api.registerCommand({
-  //   name: "upclaw",
-  //   description: "UpClaw Bounty Agents Task commands",
-  //   acceptsArgs: true,
-  //   handler: async (ctx: any) => {
-  //     const args = ctx.args?.trim() ?? "";
-  //     const tokens = args.split(/\s+/).filter(Boolean);
-  //     const action = (tokens[0] ?? "status").toLowerCase();
-
-  //     if (action === "init") {
-  //       // try {
-  //       //   if (!fs.existsSync(KEY_PATH)) {
-  //       //     const pk = generatePrivateKey();
-  //       //     fs.writeFileSync(KEY_PATH, pk, "utf-8");
-  //       //     return json({
-  //       //       text: `Initialized new EVM private key and saved to ${KEY_PATH}`,
-  //       //     });
-  //       //   } else {
-  //       //     return json({
-  //       //       text: `EVM private key already exists at ${KEY_PATH}`,
-  //       //     });
-  //       //   }
-  //       // } catch (error: any) {
-  //       //   return json({
-  //       //     text: "Failed to initialize key:",
-  //       //     error: error.message,
-  //       //   });
-  //       // }
-  //     }
-
-  //     return json({
-  //       text: ["UpClaw Bounty Agents Task commands:", "", "/upclaw-task init"].join("\n"),
-  //     });
-  //   },
-  // });
-
-  registerPublisherTools(api);
-  registerWorkerTools(api);
-}

package/src/escrow.ts

@@ -1,27 +0,0 @@
-import { Hex, encodePacked, getAddress, keccak256, stringToBytes } from 'viem';
-
-export const taskDepositKey = (taskId: string): Hex => keccak256(stringToBytes(taskId));
-
-export const buildSettleDataHash = (
-  contractAddress: string,
-  key: Hex,
-  owner: string,
-  token: string,
-  worker: string,
-  amount: bigint
-): Hex => {
-  return keccak256(
-    encodePacked(
-      ['string', 'address', 'bytes32', 'address', 'address', 'address', 'uint256'],
-      [
-        'SETTLE',
-        getAddress(contractAddress as `0x${string}`),
-        key,
-        getAddress(owner as `0x${string}`),
-        getAddress(token as `0x${string}`),
-        getAddress(worker as `0x${string}`),
-        amount
-      ]
-    )
-  );
-};

package/src/helper.ts

@@ -1,23 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-
-export function json(data: unknown) {
-  return {
-    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  };
-}
-
-export const KEY_PATH = path.join(os.homedir(), ".bountyagents_key");
-
-export function getPrivateKey(): `0x${string}` {
-  if (fs.existsSync(KEY_PATH)) {
-    const key = fs.readFileSync(KEY_PATH, "utf-8").trim();
-    if (key.startsWith("0x")) {
-      return key as `0x${string}`;
-    }
-  }
-  // Fallback to the default one if the file doesn't exist to not break existing functionality directly, but throw error if user wants to use init
-  return "0x289f92dd30c36ff24b75b48623c70dea2b428dabac7a52c5ca810bcda64d861b";
-}

package/src/index.ts

@@ -1,431 +0,0 @@
-import { fetch } from "undici";
-import { z } from "zod";
-import { getAddress, Hex } from "viem";
-import { ResponseRecord, TaskRecord, responseRecordSchema, taskRecordSchema } from "./task-db-types.js";
-import { Signer } from "./signers.js";
-import {
-  CancelTaskPayload,
-  CreateTaskPayload,
-  DecisionPayload,
-  FundTaskPayload,
-  SettleTaskPayload,
-  SubmitResponsePayload,
-  TaskQueryPayload,
-  TaskResponsesQueryPayload,
-  WorkerResponsesQueryPayload,
-  cancelTaskPayloadSchema,
-  createTaskPayloadSchema,
-  decisionPayloadSchema,
-  fundTaskPayloadSchema,
-  settleTaskPayloadSchema,
-  submitResponsePayloadSchema,
-  taskQueryPayloadSchema,
-  taskResponsesQueryPayloadSchema,
-  workerResponsesQueryPayloadSchema,
-} from "./types.js";
-import {
-  cancelTaskSignaturePayload,
-  decisionSignaturePayload,
-  responseSignaturePayload,
-  taskFundSignaturePayload,
-  taskResponsesQuerySignaturePayload,
-  taskSettleSignaturePayload,
-  taskSignaturePayload,
-  workerResponsesQuerySignaturePayload,
-} from "./signing.js";
-import { parseTokenIdentifier } from "./token.js";
-import { buildSettleDataHash, taskDepositKey } from "./escrow.js";
-
-export interface BountyAgentsPluginOptions {
-  serviceUrl: string;
-  contractAddress: string;
-}
-
-export interface PluginTool {
-  name: string;
-  description: string;
-  inputSchema: z.ZodTypeAny;
-  execute: (input: unknown) => Promise<unknown>;
-}
-
-const normalizeUrl = (url: string) => url.replace(/\/$/, "");
-
-const taskResponseSchema = z.object({ task: taskRecordSchema });
-const submissionResponseSchema = z.object({ response: responseRecordSchema });
-const tasksListSchema = z.object({ tasks: z.array(taskRecordSchema) });
-const responsesListSchema = z.object({
-  responses: z.array(responseRecordSchema),
-});
-const settleResponseSchema = z.object({
-  task: taskRecordSchema,
-  settlementSignature: z.string(),
-});
-
-abstract class BaseBountyPlugin {
-  protected readonly baseUrl: string;
-  protected readonly contractAddress: `0x${string}`;
-  private readonly tools: PluginTool[] = [];
-
-  constructor(
-    protected readonly signer: Signer,
-    options: BountyAgentsPluginOptions
-  ) {
-    this.baseUrl = normalizeUrl(options.serviceUrl);
-    this.contractAddress = getAddress(options.contractAddress as `0x${string}`);
-  }
-
-  getTools(): PluginTool[] {
-    return this.tools;
-  }
-
-  async executeTool(name: string, input: unknown): Promise<unknown> {
-    const tool = this.tools.find((t) => t.name === name);
-    if (!tool) {
-      throw new Error(`Tool ${name} not found`);
-    }
-    return tool.execute(input);
-  }
-
-  protected registerTool<TSchema extends z.ZodTypeAny>(
-    name: string,
-    description: string,
-    schema: TSchema,
-    executor: (input: z.infer<TSchema>) => Promise<unknown>
-  ) {
-    this.tools.push({
-      name,
-      description,
-      inputSchema: schema,
-      execute: (rawInput: unknown) => executor(schema.parse(rawInput)),
-    });
-  }
-
-  protected async request(
-    path: string,
-    body?: unknown,
-    method: "GET" | "POST" = "POST"
-  ): Promise<unknown> {
-    const response = await fetch(`${this.baseUrl}${path}`, {
-      method,
-      headers: {
-        "content-type": "application/json",
-      },
-      body: body ? JSON.stringify(body) : undefined,
-    });
-    const payload = await response.text();
-    const data = payload ? JSON.parse(payload) : {};
-    if (!response.ok) {
-      const errorMessage =
-        typeof data.message === "string" ? data.message : response.statusText;
-      throw new Error(`Service error: ${errorMessage}`);
-    }
-    return data;
-  }
-
-  protected signPayload(payload: string): Promise<Hex> {
-    return this.signer.signMessage(payload);
-  }
-
-  protected signDigest(digest: Hex): Promise<Hex> {
-    return this.signer.signDigest(digest);
-  }
-
-  protected async fetchTask(taskId: string): Promise<TaskRecord> {
-    const response = await this.request(`/tasks/${taskId}`, undefined, "GET");
-    return taskResponseSchema.parse(response).task;
-  }
-
-  protected async fetchResponse(responseId: string): Promise<ResponseRecord> {
-    const response = await this.request(
-      `/responses/${responseId}`,
-      undefined,
-      "GET"
-    );
-    return submissionResponseSchema.parse(response).response;
-  }
-}
-
-export class BountyAgentsPublisherPlugin extends BaseBountyPlugin {
-  constructor(signer: Signer, options: BountyAgentsPluginOptions) {
-    super(signer, options);
-    this.registerTool(
-      "bountyagents.publisher.task.create",
-      "Create a draft bounty task on the remote service",
-      createTaskPayloadSchema,
-      (input) => this.createTask(input)
-    );
-    this.registerTool(
-      "bountyagents.publisher.task.fund",
-      "Attach price/token metadata after depositing escrow funds",
-      fundTaskPayloadSchema,
-      (input) => this.fundTask(input)
-    );
-    this.registerTool(
-      "bountyagents.publisher.task.decision",
-      "Approve or reject a response and cache the settlement signature",
-      decisionPayloadSchema,
-      (input) => this.decideOnResponse(input)
-    );
-    this.registerTool(
-      "bountyagents.publisher.task.cancel",
-      "Cancel an active task and retrieve the admin withdraw signature",
-      cancelTaskPayloadSchema,
-      (input) => this.cancelTask(input)
-    );
-    this.registerTool(
-      "bountyagents.publisher.task.query",
-      "Search tasks with keyword, publisher and price filters",
-      taskQueryPayloadSchema,
-      (input) => this.queryTasks(input)
-    );
-    this.registerTool(
-      "bountyagents.publisher.task.response.query",
-      "List responses for a task (owner signature required)",
-      taskResponsesQueryPayloadSchema,
-      (input) => this.queryTaskResponses(input)
-    );
-  }
-
-  private async createTask(payload: CreateTaskPayload): Promise<TaskRecord> {
-    const body = {
-      ...payload,
-      ownerAddress: this.signer.address,
-      signature: await this.signPayload(taskSignaturePayload(payload)),
-    };
-    const response = await this.request("/tasks", body);
-    return taskResponseSchema.parse(response).task;
-  }
-
-  private async fundTask(payload: FundTaskPayload): Promise<TaskRecord> {
-    const body = {
-      ...payload,
-      ownerAddress: this.signer.address,
-      signature: await this.signPayload(taskFundSignaturePayload(payload)),
-    };
-    const response = await this.request(`/tasks/${payload.taskId}/fund`, body);
-    return taskResponseSchema.parse(response).task;
-  }
-
-  private async decideOnResponse(
-    payload: DecisionPayload
-  ): Promise<ResponseRecord> {
-    const responseRecord = await this.fetchResponse(payload.responseId);
-    const task = await this.fetchTask(responseRecord.task_id);
-    if (!task.token || task.price === "0") {
-      throw new Error("Task is not funded yet");
-    }
-    
-    // Use the price from the task record for the settlement signature
-    const taskPrice = task.price;
-    
-    if (payload.price !== taskPrice) {
-      throw new Error(`Price mismatch: payload price ${payload.price} does not match task price ${taskPrice}`);
-    }
-    const workerAddress = getAddress(payload.workerAddress as `0x${string}`);
-    if (workerAddress !== getAddress(responseRecord.worker as `0x${string}`)) {
-      throw new Error("Worker address mismatch");
-    }
-
-    const settlementSignature =
-      payload.status === "approved"
-        ? await this.createSettlementSignature(
-            responseRecord.task_id,
-            workerAddress,
-            taskPrice,
-            task.token
-          )
-        : undefined;
-
-    const body = {
-      responseId: payload.responseId,
-      workerAddress,
-      price: payload.price,
-      status: payload.status,
-      settlementSignature,
-      ownerAddress: this.signer.address,
-      signature: await this.signPayload(
-        decisionSignaturePayload({
-          responseId: payload.responseId,
-          workerAddress,
-          price: payload.price,
-          status: payload.status,
-          settlementSignature,
-        })
-      ),
-    };
-    const response = await this.request(
-      `/responses/${payload.responseId}/decision`,
-      body
-    );
-    return submissionResponseSchema.parse(response).response;
-  }
-
-  private async cancelTask(payload: CancelTaskPayload): Promise<TaskRecord> {
-    const body = {
-      ...payload,
-      ownerAddress: this.signer.address,
-      signature: await this.signPayload(cancelTaskSignaturePayload(payload)),
-    };
-    const response = await this.request(
-      `/tasks/${payload.taskId}/cancel`,
-      body
-    );
-    return taskResponseSchema.parse(response).task;
-  }
-
-  private async queryTasks(payload: TaskQueryPayload): Promise<TaskRecord[]> {
-    const canonicalFilter = (payload.filter ?? {}) as NonNullable<
-      TaskQueryPayload["filter"]
-    >;
-    const pageSize = payload.pageSize ?? 50;
-    const pageNum = payload.pageNum ?? 0;
-    const body = {
-      filter: canonicalFilter,
-      sortBy: payload.sortBy ?? "created_at",
-      pageSize,
-      pageNum,
-    };
-    const response = await this.request("/tasks/query", body);
-    return tasksListSchema.parse(response).tasks;
-  }
-
-  private async queryTaskResponses(
-    payload: TaskResponsesQueryPayload
-  ): Promise<ResponseRecord[]> {
-    const pageSize = payload.pageSize ?? 50;
-    const pageNum = payload.pageNum ?? 0;
-    const canonicalPayload = {
-      taskId: payload.taskId,
-      workerAddress: payload.workerAddress,
-      pageSize,
-      pageNum,
-    };
-    const body = {
-      ...canonicalPayload,
-      ownerAddress: this.signer.address,
-      signature: await this.signPayload(
-        taskResponsesQuerySignaturePayload({
-          ...canonicalPayload,
-          ownerAddress: this.signer.address,
-        })
-      ),
-    };
-    const response = await this.request("/tasks/responses/query", body);
-    return responsesListSchema.parse(response).responses;
-  }
-
-  private async createSettlementSignature(
-    taskId: string,
-    workerAddress: `0x${string}`,
-    price: string,
-    tokenIdentifier: string
-  ): Promise<Hex> {
-    const token = parseTokenIdentifier(tokenIdentifier);
-    const depositKey = taskDepositKey(taskId);
-    const digest = buildSettleDataHash(
-      this.contractAddress,
-      depositKey,
-      this.signer.address,
-      token.address,
-      workerAddress,
-      BigInt(price)
-    );
-    return this.signDigest(digest);
-  }
-}
-
-export class BountyAgentsWorkerPlugin extends BaseBountyPlugin {
-  constructor(signer: Signer, options: BountyAgentsPluginOptions) {
-    super(signer, options);
-    this.registerTool(
-      "bountyagents.worker.task.respond",
-      "Submit a response for an active task",
-      submitResponsePayloadSchema,
-      (input) => this.submitResponse(input)
-    );
-    this.registerTool(
-      "bountyagents.worker.response.query",
-      "List responses submitted by this worker",
-      workerResponsesQueryPayloadSchema,
-      (input) => this.queryWorkerResponses(input)
-    );
-    this.registerTool(
-      "bountyagents.worker.task.query",
-      "Search tasks with keyword, publisher and price filters",
-      taskQueryPayloadSchema,
-      (input) => this.queryTasks(input)
-    );
-  }
-
-  private async queryTasks(payload: TaskQueryPayload): Promise<TaskRecord[]> {
-    const canonicalFilter = (payload.filter ?? {}) as NonNullable<
-      TaskQueryPayload["filter"]
-    >;
-    const pageSize = payload.pageSize ?? 50;
-    const pageNum = payload.pageNum ?? 0;
-    const body = {
-      filter: canonicalFilter,
-      sortBy: payload.sortBy ?? "created_at",
-      pageSize,
-      pageNum,
-    };
-    const response = await this.request("/tasks/query", body);
-    return tasksListSchema.parse(response).tasks;
-  }
-
-  private async submitResponse(
-    payload: SubmitResponsePayload
-  ): Promise<ResponseRecord> {
-    const body = {
-      ...payload,
-      workerAddress: this.signer.address,
-      signature: await this.signPayload(responseSignaturePayload(payload)),
-    };
-    const response = await this.request(
-      `/tasks/${payload.taskId}/responses`,
-      body
-    );
-    return submissionResponseSchema.parse(response).response;
-  }
-
-  private async queryWorkerResponses(
-    payload: WorkerResponsesQueryPayload
-  ): Promise<ResponseRecord[]> {
-    const pageSize = payload.pageSize ?? 50;
-    const pageNum = payload.pageNum ?? 0;
-    const canonicalPayload = {
-      taskId: payload.taskId,
-      pageSize,
-      pageNum,
-    };
-    const body = {
-      ...canonicalPayload,
-      workerAddress: this.signer.address,
-      signature: await this.signPayload(
-        workerResponsesQuerySignaturePayload({
-          ...canonicalPayload,
-          workerAddress: this.signer.address,
-        })
-      ),
-    };
-    const response = await this.request("/workers/responses/query", body);
-    return responsesListSchema.parse(response).responses;
-  }
-
-  private async settleTask(
-    payload: SettleTaskPayload
-  ): Promise<{ task: TaskRecord; settlementSignature: string }> {
-    const canonicalPayload = { ...payload, workerAddress: this.signer.address };
-    const body = {
-      ...canonicalPayload,
-      signature: await this.signPayload(
-        taskSettleSignaturePayload(canonicalPayload)
-      ),
-    };
-    const response = await this.request(
-      `/tasks/${payload.taskId}/settle`,
-      body
-    );
-    return settleResponseSchema.parse(response);
-  }
-}