@lucid-agents/taskmarket 1.0.0 → 1.1.0

package/dist/index.js

@@ -638,9 +638,14 @@ var getCmd = new Command7("get").description("Get task details").argument("<task
 });
 
 // src/commands/task/submit.ts
-import { Command as Command8 } from "commander";
-import { promises as fs2 } from "fs";
+import { Command as Command8, Option } from "commander";
+import { promises as fsPromises } from "fs";
 import { basename, extname } from "path";
+import { createHash } from "crypto";
+import { Readable } from "stream";
+import https from "https";
+import http from "http";
+import { keccak256 } from "viem";
 function collectFile(value, previous) {
   return [...previous, value];
 }
@@ -679,30 +684,98 @@ function mimeTypeForPath(filePath) {
       return "application/octet-stream";
   }
 }
-var submitCmd = new Command8("submit").description("Submit work for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").option("--file <path>", "Path to a submission file (repeatable)", collectFile, []).action(async (taskId, opts) => {
+function streamingPut(uploadUrl, data, mimeType, label) {
+  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) {
+            process.stderr.write("\n");
+            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;
+      const pct = Math.round(uploaded / data.length * 100);
+      process.stderr.write(`\r  ${label}: ${pct}%`);
+    });
+    stream.on("error", reject);
+    stream.pipe(req);
+  });
+}
+var submitCmd = new Command8("submit").description("Submit work for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").option("--file <path>", "Path to a submission file (repeatable)", collectFile, []).addOption(
+  new Option("--role <role>", "Artifact role applied to all files").choices(["preview", "source", "final", "attachment"]).default("attachment")
+).action(async (taskId, opts) => {
   try {
     if (!opts.file || opts.file.length === 0) {
       printError("--file is required");
     }
     const keystore = await loadKeystore();
     const signature = await signMessage(`taskmarket:submit:${taskId}`, keystore);
-    const body = {
-      workerAddress: keystore.walletAddress,
-      signature,
-      artifacts: await Promise.all(
-        opts.file.map(async (filePath) => {
-          const fileContent = await fs2.readFile(filePath);
-          return {
+    const artifactInputs = await Promise.all(
+      opts.file.map(async (filePath) => {
+        const mimeType = mimeTypeForPath(filePath);
+        const data = await fsPromises.readFile(filePath);
+        if (data.length === 0) {
+          printError(`File is empty: ${basename(filePath)}`);
+        }
+        const { uploadUrl, artifactKey } = await apiPost(
+          `/api/tasks/${taskId}/submissions/request-upload-url`,
+          {
+            taskId,
+            workerAddress: keystore.walletAddress,
+            signature,
             fileName: basename(filePath),
-            mimeType: mimeTypeForPath(filePath),
-            role: "attachment",
-            file: fileContent.toString("base64")
-          };
-        })
-      )
-    };
-    const result = await apiPost(`/api/tasks/${taskId}/submissions`, {
-      ...body
+            mimeType,
+            role: opts.role,
+            sizeBytes: data.length
+          }
+        );
+        const sha256Hash = createHash("sha256").update(data).digest("hex");
+        const keccak256Hash = keccak256(new Uint8Array(data));
+        process.stderr.write(`  Uploading ${basename(filePath)}...
+`);
+        await streamingPut(uploadUrl, data, mimeType, basename(filePath));
+        return {
+          artifactKey,
+          fileName: basename(filePath),
+          mimeType,
+          role: opts.role,
+          sizeBytes: data.length,
+          sha256Hash,
+          keccak256Hash
+        };
+      })
+    );
+    const result = await apiPost(`/api/tasks/${taskId}/submissions/from-keys`, {
+      taskId,
+      workerAddress: keystore.walletAddress,
+      artifacts: artifactInputs,
+      signature
     });
     printResult({ submissionId: result.submissionId });
   } finally {
@@ -831,10 +904,10 @@ var pitchCmd = new Command13("pitch").description("Submit a pitch for a task (co
 
 // src/commands/task/select-worker.ts
 import { Command as Command14 } from "commander";
-import { keccak256, toBytes } from "viem";
+import { keccak256 as keccak2562, toBytes } from "viem";
 var selectWorkerCmd = new Command14("select-worker").description("Select a worker from pitches (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--pitch <pitchId>", "Pitch ID to select").requiredOption("--worker <address>", "Worker wallet address to assign").action(async (taskId, opts) => {
   const keystore = await loadKeystore();
-  const hash = keccak256(toBytes(taskId + opts.pitch + opts.worker));
+  const hash = keccak2562(toBytes(taskId + opts.pitch + opts.worker));
   const signature = await signMessage(hash, keystore);
   await apiPost(`/api/tasks/${taskId}/pitches/select`, {
     taskId,
@@ -1510,11 +1583,11 @@ var withdrawCommand = new Command38("withdraw").description("Withdraw USDC to th
 
 // src/commands/encrypt.ts
 import { Command as Command39 } from "commander";
-import { promises as fs3 } from "fs";
+import { promises as fs2 } from "fs";
 var encryptCommand = new Command39("encrypt").description("Encrypt a file with ECIES using wallet keys").argument("<file>", "Path to the file to encrypt").option("--recipient <address>", "Recipient wallet address (default: self)").option("--output <path>", "Output path (default: <file>.enc)").action(async (file, opts) => {
   let plaintext;
   try {
-    plaintext = await fs3.readFile(file);
+    plaintext = await fs2.readFile(file);
   } catch {
     printError(`Cannot read file: ${file}`);
   }
@@ -1551,7 +1624,7 @@ var encryptCommand = new Command39("encrypt").description("Encrypt a file with E
   }
   const encrypted = encryptForRecipient(plaintext, recipientPubKey);
   const outputPath = opts.output ?? `${file}.enc`;
-  await fs3.writeFile(outputPath, encrypted);
+  await fs2.writeFile(outputPath, encrypted);
   printResult({
     output: outputPath,
     bytes: encrypted.length,
@@ -1561,11 +1634,11 @@ var encryptCommand = new Command39("encrypt").description("Encrypt a file with E
 
 // src/commands/decrypt.ts
 import { Command as Command40 } from "commander";
-import { promises as fs4 } from "fs";
+import { promises as fs3 } from "fs";
 var decryptCommand = new Command40("decrypt").description("Decrypt a file using your wallet key").argument("<file>", "Path to the encrypted file").option("--output <path>", "Output path (default: strips .enc, otherwise appends .dec)").action(async (file, opts) => {
   let ciphertext;
   try {
-    ciphertext = await fs4.readFile(file);
+    ciphertext = await fs3.readFile(file);
   } catch {
     printError(`Cannot read file: ${file}`);
   }
@@ -1592,7 +1665,7 @@ var decryptCommand = new Command40("decrypt").description("Decrypt a file using
   } else {
     outputPath = `${file}.dec`;
   }
-  await fs4.writeFile(outputPath, plaintext);
+  await fs3.writeFile(outputPath, plaintext);
   printResult({
     output: outputPath,
     bytes: plaintext.length
@@ -5806,9 +5879,9 @@ var UpdateTaskInputSchema = external_exports.object({
   pitchDeadline: external_exports.number().optional(),
   auctionFloorPrice: external_exports.string().optional(),
   auctionStartPrice: external_exports.string().optional(),
-  description: external_exports.string().optional(),
-  tags: external_exports.array(external_exports.string()).optional(),
-  metricDescription: external_exports.string().optional()
+  description: external_exports.string().max(2e3, "Description is too long").optional(),
+  tags: external_exports.array(external_exports.string()).max(10, "Maximum 10 tags allowed").optional(),
+  metricDescription: external_exports.string().max(500).optional()
 });
 
 // ../../packages/shared/dist/schemas/submission.schemas.js
@@ -5878,6 +5951,35 @@ var DownloadResponseSchema = external_exports.object({
   keyBundle: external_exports.string().nullable().optional(),
   expiresAt: external_exports.string()
 });
+var MAX_ARTIFACT_BYTES = 500 * 1024 * 1024;
+var RequestUploadUrlInputSchema = external_exports.object({
+  taskId: external_exports.string(),
+  workerAddress: external_exports.string(),
+  signature: external_exports.string(),
+  fileName: external_exports.string().min(1, "File name is required").max(255, "File name is too long"),
+  mimeType: external_exports.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
+  role: ArtifactRole.optional().default("attachment"),
+  sizeBytes: external_exports.number().int().positive("Size must be positive").max(MAX_ARTIFACT_BYTES, "File must not exceed 500 MB")
+});
+var RequestUploadUrlOutputSchema = external_exports.object({
+  uploadUrl: external_exports.string(),
+  artifactKey: external_exports.string()
+});
+var ArtifactKeyInputSchema = external_exports.object({
+  artifactKey: external_exports.string().min(1, "Artifact key is required"),
+  fileName: external_exports.string().min(1, "File name is required").max(255, "File name is too long"),
+  mimeType: external_exports.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
+  role: ArtifactRole.optional().default("attachment"),
+  sizeBytes: external_exports.number().int().positive("Size must be positive").max(MAX_ARTIFACT_BYTES, "File must not exceed 500 MB"),
+  sha256Hash: external_exports.string().regex(/^[0-9a-f]{64}$/, "sha256Hash must be 64 lowercase hex chars"),
+  keccak256Hash: external_exports.string().regex(/^0x[0-9a-fA-F]{64}$/, "keccak256Hash must be 0x followed by 64 hex chars")
+});
+var SubmissionCreateFromKeysSchema = external_exports.object({
+  taskId: external_exports.string(),
+  workerAddress: external_exports.string(),
+  artifacts: external_exports.array(ArtifactKeyInputSchema).min(1).max(20),
+  signature: external_exports.string()
+});
 
 // ../../packages/shared/dist/schemas/agent.schemas.js
 var ActorType = external_exports.enum(["agent", "human"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucid-agents/taskmarket",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "bin": {
     "taskmarket": "./dist/index.js"