@lucid-agents/taskmarket 1.17.2 → 1.18.0

package/dist/chunk-JJUF3KZY.js

@@ -0,0 +1,447 @@
+import { createRequire as __tmCreateRequire } from 'node:module'; import { fileURLToPath as __tmFileURLToPath } from 'node:url'; import { dirname as __tmDirname } from 'node:path'; const require = __tmCreateRequire(import.meta.url); const __tmFilename = __tmFileURLToPath(import.meta.url); const __tmDirnameValue = __tmDirname(__tmFilename);
+import {
+  x402FeePost
+} from "./chunk-W7CXEYST.js";
+import {
+  createWalletAccountFromKeystore,
+  signMessage
+} from "./chunk-S4A6V3J3.js";
+import {
+  READ_AUTH_ADDRESS_HEADER,
+  READ_AUTH_SIGNATURE_HEADER,
+  TASK_ACCESS_GRANT_HEADER,
+  apiGet,
+  apiPost,
+  buildClaimMessage,
+  buildReadAuthMessage,
+  buildSubmitMessage,
+  getTaskmarketHome,
+  isRecordingPendingResponse,
+  loadKeystore
+} from "./chunk-75LS6XS6.js";
+
+// src/lib/read-auth.ts
+async function signReadAuth() {
+  let keystore;
+  try {
+    keystore = await loadKeystore();
+  } catch {
+    return null;
+  }
+  try {
+    const account = await createWalletAccountFromKeystore(keystore);
+    const signature = await account.signMessage({
+      message: buildReadAuthMessage(keystore.walletAddress)
+    });
+    return {
+      walletAddress: keystore.walletAddress,
+      headers: {
+        [READ_AUTH_ADDRESS_HEADER]: keystore.walletAddress,
+        [READ_AUTH_SIGNATURE_HEADER]: signature
+      }
+    };
+  } catch {
+    return { walletAddress: keystore.walletAddress, headers: {} };
+  }
+}
+
+// src/lib/task-access-grants.ts
+import { promises as fs } from "fs";
+import path from "path";
+function getGrantsPath() {
+  return path.join(getTaskmarketHome(), "task-access-grants.json");
+}
+async function readGrantsFile() {
+  try {
+    const raw = await fs.readFile(getGrantsPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function loadTaskAccessGrant(taskId) {
+  const grants = await readGrantsFile();
+  const record = grants[taskId];
+  if (!record) return null;
+  if (new Date(record.expiresAt).getTime() <= Date.now()) return null;
+  return record.grant;
+}
+async function taskAccessGrantHeaders(taskId) {
+  const grant = await loadTaskAccessGrant(taskId);
+  return grant ? { [TASK_ACCESS_GRANT_HEADER]: grant } : {};
+}
+async function saveTaskAccessGrant(taskId, grant, expiresAt) {
+  const grants = await readGrantsFile();
+  grants[taskId] = { grant, expiresAt };
+  const dir = path.dirname(getGrantsPath());
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(getGrantsPath(), JSON.stringify(grants, null, 2), {
+    mode: 384
+  });
+}
+
+// src/sdk/artifact-upload.ts
+import { extname } from "path";
+import { Readable } from "stream";
+import https from "https";
+import http from "http";
+function mimeTypeForPath(filePath) {
+  switch (extname(filePath).toLowerCase()) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    case ".svg":
+      return "image/svg+xml";
+    case ".pdf":
+      return "application/pdf";
+    case ".mp4":
+      return "video/mp4";
+    case ".webm":
+      return "video/webm";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".wav":
+      return "audio/wav";
+    case ".md":
+      return "text/markdown";
+    case ".txt":
+      return "text/plain";
+    case ".json":
+      return "application/json";
+    case ".zip":
+      return "application/zip";
+    default:
+      return "application/octet-stream";
+  }
+}
+function putArtifactBytes(uploadUrl, data, mimeType, onProgress) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(uploadUrl);
+    const transport = url.protocol === "https:" ? https : http;
+    const req = transport.request(
+      url,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": mimeType,
+          "Content-Length": String(data.length)
+        }
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve();
+          } else {
+            const body = Buffer.concat(chunks).toString("utf8").slice(0, 500);
+            reject(
+              new Error(
+                `Upload failed (${res.statusCode ?? "unknown"}): ${body || "no response body"}`
+              )
+            );
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    let uploaded = 0;
+    const stream = Readable.from([data]);
+    stream.on("data", (chunk) => {
+      uploaded += chunk.length;
+      onProgress?.(Math.round(uploaded / data.length * 100));
+    });
+    stream.on("error", reject);
+    stream.pipe(req);
+  });
+}
+
+// src/lib/task-sdk.ts
+async function putWithProgress(upload) {
+  process.stderr.write(`  Uploading ${upload.fileName}...
+`);
+  await putArtifactBytes(upload.uploadUrl, upload.data, upload.mimeType, (percent) => {
+    process.stderr.write(`\r  ${upload.fileName}: ${percent}%`);
+  });
+  process.stderr.write("\n");
+}
+var cliTaskTransport = {
+  get: (path2, headers) => apiGet(path2, { headers }),
+  // A write the caller gave no key is sent exactly as before the SDK existed, with no options,
+  // so `apiPost` resolves its key itself (explicit, then TASKMARKET_IDEMPOTENCY_KEY, then fresh).
+  post: (path2, body, options) => options === void 0 ? apiPost(path2, body) : apiPost(path2, body, options),
+  feePost: (path2, body, options) => x402FeePost(path2, body, options),
+  put: putWithProgress
+};
+function keystoreTaskSigner(keystore) {
+  return {
+    address: keystore.walletAddress,
+    signMessage: (message) => signMessage(message, keystore)
+  };
+}
+function cliTaskReadContext() {
+  return {
+    transport: cliTaskTransport,
+    readAuth: signReadAuth,
+    accessGrantHeaders: taskAccessGrantHeaders
+  };
+}
+function cliTaskWriteContext(keystore) {
+  return { ...cliTaskReadContext(), signer: keystoreTaskSigner(keystore) };
+}
+
+// src/sdk/tasks.ts
+import { promises as fsPromises } from "fs";
+import { basename } from "path";
+import { createHash } from "crypto";
+import { keccak256 } from "viem";
+var TaskOperationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "TaskOperationError";
+    this.code = code;
+  }
+};
+function withChainQuery(path2, chainId) {
+  if (chainId === void 0) return path2;
+  return `${path2}${path2.includes("?") ? "&" : "?"}chainId=${chainId}`;
+}
+function withChainBody(body, chainId) {
+  return chainId === void 0 ? body : { ...body, chainId };
+}
+function writeOptions(idempotencyKey) {
+  return idempotencyKey === void 0 ? void 0 : { idempotencyKey };
+}
+async function readAuthHeaders(ctx) {
+  return (await ctx.readAuth?.())?.headers ?? {};
+}
+async function getTask(ctx, ref) {
+  const headers = {
+    ...await readAuthHeaders(ctx),
+    ...await ctx.accessGrantHeaders?.(ref.taskId) ?? {}
+  };
+  const task = await ctx.transport.get(
+    withChainQuery(`/api/tasks/${ref.taskId}`, ref.chainId),
+    headers
+  );
+  return task ?? null;
+}
+async function getTaskTerms(ctx, ref) {
+  const headers = {
+    ...await readAuthHeaders(ctx),
+    ...await ctx.accessGrantHeaders?.(ref.taskId) ?? {}
+  };
+  const detail = await ctx.transport.get(
+    withChainQuery(`/api/tasks/${ref.taskId}/terms`, ref.chainId),
+    headers
+  );
+  return detail ?? null;
+}
+async function listTasks(ctx, filter = {}) {
+  const params = new URLSearchParams();
+  if (filter.chainId !== void 0) params.set("chainId", String(filter.chainId));
+  if (filter.q) params.set("q", filter.q);
+  if (filter.sort) params.set("sort", filter.sort);
+  if (filter.status) params.set("status", filter.status);
+  if (filter.phase) params.set("phase", filter.phase);
+  if (filter.mode) params.set("mode", filter.mode);
+  if (filter.auctionType) params.set("auctionType", filter.auctionType);
+  if (filter.tags) params.set("tags", filter.tags);
+  if (filter.minReward) params.set("minReward", filter.minReward);
+  if (filter.maxReward) params.set("maxReward", filter.maxReward);
+  if (filter.deadlineHours) params.set("deadlineHours", filter.deadlineHours);
+  if (filter.limit) params.set("limit", filter.limit);
+  if (filter.cursor) params.set("cursor", filter.cursor);
+  const result = await ctx.transport.get(
+    `/api/tasks?${params.toString()}`,
+    await readAuthHeaders(ctx)
+  );
+  return { tasks: result.tasks, hasMore: result.hasMore, nextCursor: result.nextCursor };
+}
+async function listTaskSubmissions(ctx, ref) {
+  const headers = await readAuthHeaders(ctx);
+  return await ctx.transport.get(
+    withChainQuery(`/api/tasks/${ref.taskId}/submissions`, ref.chainId),
+    headers
+  );
+}
+async function listWorkerSubmissions(ctx, options = {}) {
+  const auth = await ctx.readAuth?.();
+  const address = options.address ?? auth?.walletAddress;
+  if (!address) {
+    throw new TaskOperationError(
+      "no_address",
+      "No worker address was given and there is no reading wallet to default to"
+    );
+  }
+  return ctx.transport.get(`/api/submissions/mine?workerAddress=${encodeURIComponent(address)}`, {
+    ...auth?.headers ?? {}
+  });
+}
+async function getWorkerInbox(ctx) {
+  const auth = await ctx.readAuth?.();
+  if (!auth?.walletAddress) {
+    throw new TaskOperationError("no_address", "There is no reading wallet to ask about");
+  }
+  const raw = await ctx.transport.get(
+    `/api/agents/inbox?address=${encodeURIComponent(auth.walletAddress)}`,
+    auth.headers
+  );
+  return {
+    address: auth.walletAddress,
+    proven: Object.keys(auth.headers).length > 0,
+    inbox: {
+      asRequester: raw?.asRequester ?? [],
+      asWorker: raw?.asWorker ?? [],
+      invitedPrivateTasks: raw?.invitedPrivateTasks ?? []
+    }
+  };
+}
+async function getAgentStats(ctx, options) {
+  return await ctx.transport.get(
+    withChainQuery(
+      `/api/agents/stats?address=${encodeURIComponent(options.address)}`,
+      options.chainId
+    ),
+    {}
+  );
+}
+async function claimTask(ctx, ref, options = {}) {
+  const signature = await ctx.signer.signMessage(buildClaimMessage(ref.taskId));
+  const { data, idempotencyKey } = await ctx.transport.post(
+    `/api/tasks/${ref.taskId}/claim`,
+    withChainBody({ workerAddress: ctx.signer.address, signature }, ref.chainId),
+    writeOptions(options.idempotencyKey)
+  );
+  return { claimId: data.claimId, idempotencyKey };
+}
+async function authorizeUploads(ctx, ref) {
+  return { signature: await ctx.signer.signMessage(buildSubmitMessage(ref.taskId)) };
+}
+async function readArtifactFile(file) {
+  const fileName = file.fileName ?? basename(file.path);
+  const data = await fsPromises.readFile(file.path);
+  if (data.length === 0) {
+    throw new TaskOperationError("empty_artifact", `File is empty: ${fileName}`);
+  }
+  return {
+    data,
+    artifact: {
+      fileName,
+      mimeType: file.mimeType ?? mimeTypeForPath(file.path),
+      role: file.role,
+      sizeBytes: data.length,
+      sha256Hash: createHash("sha256").update(data).digest("hex"),
+      keccak256Hash: keccak256(new Uint8Array(data))
+    }
+  };
+}
+async function requestArtifactUpload(ctx, ref, artifact, authorization) {
+  const {
+    data: { uploadUrl, artifactKey }
+  } = await ctx.transport.post(
+    `/api/tasks/${ref.taskId}/submissions/request-upload-url`,
+    withChainBody(
+      {
+        taskId: ref.taskId,
+        workerAddress: ctx.signer.address,
+        signature: authorization.signature,
+        fileName: artifact.fileName,
+        mimeType: artifact.mimeType,
+        role: artifact.role,
+        sizeBytes: artifact.sizeBytes
+      },
+      ref.chainId
+    )
+  );
+  return { uploadUrl, artifactKey };
+}
+async function uploadArtifact(ctx, ref, file, authorization) {
+  const { data, artifact } = await readArtifactFile(file);
+  const { uploadUrl, artifactKey } = await requestArtifactUpload(ctx, ref, artifact, authorization);
+  await ctx.transport.put({
+    uploadUrl,
+    data,
+    mimeType: artifact.mimeType,
+    fileName: artifact.fileName
+  });
+  return { artifactKey, ...artifact };
+}
+async function submitUploadedArtifacts(ctx, ref, artifacts, options = {}) {
+  if (artifacts.length === 0) {
+    throw new TaskOperationError("no_artifacts", "At least one artifact is required");
+  }
+  const signature = await ctx.signer.signMessage(
+    buildSubmitMessage(
+      ref.taskId,
+      artifacts.map((artifact) => artifact.artifactKey)
+    )
+  );
+  const { data, idempotencyKey } = await ctx.transport.feePost(
+    `/api/tasks/${ref.taskId}/submissions/from-keys`,
+    withChainBody(
+      {
+        taskId: ref.taskId,
+        workerAddress: ctx.signer.address,
+        artifacts,
+        signature
+      },
+      ref.chainId
+    ),
+    options
+  );
+  if (isRecordingPendingResponse(data)) {
+    return {
+      submissionId: data.submissionId,
+      idempotencyKey,
+      recordingPending: {
+        ...typeof data.intentId === "string" ? { intentId: data.intentId } : {},
+        ...typeof data.txHash === "string" ? { txHash: data.txHash } : {}
+      }
+    };
+  }
+  return { submissionId: data.submissionId, idempotencyKey };
+}
+async function submitTaskFiles(ctx, ref, files, options = {}) {
+  if (files.length === 0) {
+    throw new TaskOperationError("no_artifacts", "At least one file is required");
+  }
+  const authorization = await authorizeUploads(ctx, ref);
+  const artifacts = await Promise.all(
+    files.map((file) => uploadArtifact(ctx, ref, file, authorization))
+  );
+  return submitUploadedArtifacts(ctx, ref, artifacts, options);
+}
+
+export {
+  signReadAuth,
+  taskAccessGrantHeaders,
+  saveTaskAccessGrant,
+  mimeTypeForPath,
+  putArtifactBytes,
+  cliTaskTransport,
+  keystoreTaskSigner,
+  cliTaskReadContext,
+  cliTaskWriteContext,
+  TaskOperationError,
+  getTask,
+  getTaskTerms,
+  listTasks,
+  listTaskSubmissions,
+  listWorkerSubmissions,
+  getWorkerInbox,
+  getAgentStats,
+  claimTask,
+  authorizeUploads,
+  readArtifactFile,
+  requestArtifactUpload,
+  submitUploadedArtifacts,
+  submitTaskFiles
+};