@elisym/cli 0.22.3 → 0.22.5

package/dist/index.js

@@ -2115,6 +2115,12 @@ var SeedFailedError = class extends Error {
     this.name = "SeedFailedError";
   }
 };
+var PaymentTimeoutError = class extends Error {
+  constructor() {
+    super("Payment verification timed out; awaiting late confirmation.");
+    this.name = "PaymentTimeoutError";
+  }
+};
 var MIME_EXTENSIONS = {
   "image/png": ".png",
   "image/jpeg": ".jpg",
@@ -2544,7 +2550,7 @@ var AgentRuntime = class {
       const log = this.callbacks.onLog ?? console.log;
       log(`[${job.jobId.slice(0, 8)}] Error: ${e.message}`);
       const currentStatus = this.ledger.getStatus(job.jobId);
-      const keepPaidForRecovery = (e instanceof AgentUnavailableError || e instanceof SeedFailedError) && currentStatus === "paid";
+      const keepPaidForRecovery = (e instanceof AgentUnavailableError || e instanceof SeedFailedError || e instanceof PaymentTimeoutError) && currentStatus === "paid";
       if (currentStatus !== "executed" && !keepPaidForRecovery) {
         this.ledger.markFailed(job.jobId);
       }
@@ -2617,7 +2623,7 @@ var AgentRuntime = class {
       );
       this.callbacks.onPaymentReceived?.(job.jobId, netAmount);
     }
-    const inputFile = await this.resolveInputFile(job.attachment, job.customerId);
+    const inputFile = await this.resolveInputFile(job.attachment, job.customerId, signal);
     await this.transport.sendFeedback(job, { type: "processing" }).catch(() => {
     });
     const skill = this.skills.route(job.tags);
@@ -2760,40 +2766,55 @@ var AgentRuntime = class {
             )
           );
         }
+        let deliveredContent = output.data;
+        if (utf8ByteLength(output.data) > LIMITS.MAX_ENCRYPTED_INLINE_BYTES) {
+          attachments.push(
+            await this.spillTextAttachment(jobId, output.data, customerPubkey, wantBlossom)
+          );
+          deliveredContent = "";
+        }
         this.ledger.recordAttachment(jobId, {
           resultAttachments: attachments.map((a) => JSON.stringify(a))
         });
-        return { attachments, deliveredContent: output.data };
+        return { attachments, deliveredContent };
       } finally {
         await output.cleanup?.().catch(() => {
         });
       }
     }
     if (utf8ByteLength(output.data) > LIMITS.MAX_ENCRYPTED_INLINE_BYTES) {
-      if (!this.irohTransport) {
-        throw new Error("Result is too large to deliver inline and iroh transport is unavailable.");
-      }
-      const iroh = this.irohTransport;
-      const dataBytes = Buffer.from(output.data, "utf8");
-      const seeded = await this.seedGuarded(jobId, "large-text", () => iroh.seedBytes(dataBytes));
-      const transports = [{ kind: "iroh", ticket: seeded.ticket }];
-      if (wantBlossom) {
-        const blossomMember = await this.seedBlossomMember(dataBytes, customerPubkey);
-        if (blossomMember !== void 0) {
-          transports.unshift(blossomMember);
-        }
-      }
-      const attachment = {
-        name: "result.txt",
-        size: seeded.size,
-        mime: "text/plain",
-        transports
-      };
+      const attachment = await this.spillTextAttachment(
+        jobId,
+        output.data,
+        customerPubkey,
+        wantBlossom
+      );
       this.ledger.recordAttachment(jobId, { resultAttachments: [JSON.stringify(attachment)] });
       return { attachments: [attachment], deliveredContent: "" };
     }
     return { attachments: [], deliveredContent: output.data };
   }
+  /**
+   * Seed a text note too large for inline delivery to iroh (+ encrypted Blossom when
+   * wanted) and return it as a `result.txt` FileAttachment. Shared by the large-text
+   * result path and the file-result path (a file result may carry an oversized note).
+   */
+  async spillTextAttachment(jobId, text, customerPubkey, wantBlossom) {
+    if (!this.irohTransport) {
+      throw new Error("Result is too large to deliver inline and iroh transport is unavailable.");
+    }
+    const iroh = this.irohTransport;
+    const dataBytes = Buffer.from(text, "utf8");
+    const seeded = await this.seedGuarded(jobId, "large-text", () => iroh.seedBytes(dataBytes));
+    const transports = [{ kind: "iroh", ticket: seeded.ticket }];
+    if (wantBlossom) {
+      const blossomMember = await this.seedBlossomMember(dataBytes, customerPubkey);
+      if (blossomMember !== void 0) {
+        transports.unshift(blossomMember);
+      }
+    }
+    return { name: "result.txt", size: seeded.size, mime: "text/plain", transports };
+  }
   /**
    * Seed ONE result file to iroh (+ encrypted Blossom when wanted) and build its
    * FileAttachment. A seed timeout throws SeedFailedError (job stays `paid` for
@@ -2906,51 +2927,77 @@ var AgentRuntime = class {
    * `fetchToBytes`/`fetchToPath` enforce the real cap on the BLAKE3-verified size, so
    * an incorrect declared `size` cannot exceed the in-memory ceiling.
    */
-  async resolveInputFile(attachment, senderPubkey) {
+  async resolveInputFile(attachment, senderPubkey, signal) {
     if (attachment === void 0) {
       return void 0;
     }
-    const irohMember = attachment.transports.find(
-      (t) => t.kind === "iroh"
-    );
-    const blossomMember = attachment.transports.find(
-      (t) => t.kind === "blossom"
-    );
-    if (irohMember !== void 0 && this.irohTransport !== void 0) {
-      if (attachment.mime.startsWith("text/") && attachment.size <= LIMITS.MAX_REINLINE_TEXT_BYTES) {
-        const bytes = await this.irohTransport.fetchToBytes(irohMember.ticket, {
-          maxBytes: LIMITS.MAX_REINLINE_TEXT_BYTES
+    const fetchTimeoutMs = this.config.executionTimeoutSecs && this.config.executionTimeoutSecs > 0 ? this.config.executionTimeoutSecs * 1e3 : void 0;
+    const fetchAbort = new AbortController();
+    const onParentAbort = () => fetchAbort.abort();
+    if (signal) {
+      if (signal.aborted) {
+        fetchAbort.abort();
+      } else {
+        signal.addEventListener("abort", onParentAbort);
+      }
+    }
+    const budgetTimer = fetchTimeoutMs !== void 0 ? setTimeout(() => fetchAbort.abort(), fetchTimeoutMs) : void 0;
+    try {
+      const irohMember = attachment.transports.find(
+        (t) => t.kind === "iroh"
+      );
+      const blossomMember = attachment.transports.find(
+        (t) => t.kind === "blossom"
+      );
+      if (irohMember !== void 0 && this.irohTransport !== void 0) {
+        if (attachment.mime.startsWith("text/") && attachment.size <= LIMITS.MAX_REINLINE_TEXT_BYTES) {
+          const bytes = await this.irohTransport.fetchToBytes(irohMember.ticket, {
+            maxBytes: LIMITS.MAX_REINLINE_TEXT_BYTES,
+            timeoutMs: fetchTimeoutMs,
+            signal: fetchAbort.signal
+          });
+          return this.materializeBytesInput(bytes, attachment.mime);
+        }
+        const dir = await mkdtemp(join(tmpdir(), "elisym-job-"));
+        const filePath = join(dir, "input");
+        try {
+          await this.irohTransport.fetchToPath(irohMember.ticket, filePath, {
+            timeoutMs: fetchTimeoutMs,
+            signal: fetchAbort.signal
+          });
+        } catch (error) {
+          await rm(dir, { recursive: true, force: true }).catch(() => {
+          });
+          throw error;
+        }
+        return {
+          filePath,
+          cleanup: async () => {
+            await rm(dir, { recursive: true, force: true });
+          }
+        };
+      }
+      if (blossomMember !== void 0 && this.blossomTransport !== void 0 && this.identity !== void 0) {
+        if (attachment.size > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+          throw new Error("Blossom file input exceeds the encrypted size cap.");
+        }
+        const bytes = await this.blossomTransport.fetchToBytes({
+          transport: blossomMember,
+          senderPubkey,
+          maxBytes: LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES,
+          signal: fetchAbort.signal
         });
         return this.materializeBytesInput(bytes, attachment.mime);
       }
-      const dir = await mkdtemp(join(tmpdir(), "elisym-job-"));
-      const filePath = join(dir, "input");
-      try {
-        await this.irohTransport.fetchToPath(irohMember.ticket, filePath);
-      } catch (error) {
-        await rm(dir, { recursive: true, force: true }).catch(() => {
-        });
-        throw error;
+      throw new Error("Job carries a file input but no supported transport is available.");
+    } finally {
+      if (budgetTimer !== void 0) {
+        clearTimeout(budgetTimer);
       }
-      return {
-        filePath,
-        cleanup: async () => {
-          await rm(dir, { recursive: true, force: true });
-        }
-      };
-    }
-    if (blossomMember !== void 0 && this.blossomTransport !== void 0 && this.identity !== void 0) {
-      if (attachment.size > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
-        throw new Error("Blossom file input exceeds the encrypted size cap.");
+      if (signal) {
+        signal.removeEventListener("abort", onParentAbort);
       }
-      const bytes = await this.blossomTransport.fetchToBytes({
-        transport: blossomMember,
-        senderPubkey,
-        maxBytes: LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES
-      });
-      return this.materializeBytesInput(bytes, attachment.mime);
     }
-    throw new Error("Job carries a file input but no supported transport is available.");
   }
   /**
    * Turn fetched input bytes into a SkillInput: text within the re-inline ceiling becomes an
@@ -3147,7 +3194,10 @@ var AgentRuntime = class {
     }
     await this.transport.sendFeedback(job, { type: "error", message: "payment timeout" }).catch(() => {
     });
-    throw new Error("Payment timeout");
+    if (customerAbandoned) {
+      throw new Error("Payment timeout");
+    }
+    throw new PaymentTimeoutError();
   }
   async recoverPendingJobs() {
     const pending = this.ledger.pendingJobs().filter((e) => !this.inFlight.has(e.job_id));
@@ -3303,9 +3353,15 @@ var AgentRuntime = class {
         }
         let recoveryInputFile;
         try {
+          const encrypted = rawEvent.tags?.some(
+            (tag) => tag[0] === "encrypted" && tag[1] === "nip44"
+          );
+          const iTag = rawEvent.tags?.find((tag) => tag[0] === "i");
+          const rawInput = encrypted ? rawEvent.content : iTag?.[1] ?? rawEvent.content;
           recoveryInputFile = await this.resolveInputFile(
-            decodeJobPayload(rawEvent.content).attachment,
-            entry.customer_id
+            decodeJobPayload(rawInput).attachment,
+            entry.customer_id,
+            recoveryAbort.signal
           );
         } catch {
           log(`[${entry.job_id.slice(0, 8)}] Recovery: input file unavailable, marking failed`);
@@ -3341,6 +3397,9 @@ var AgentRuntime = class {
           } else {
             output = await execPromise;
           }
+        } catch (err) {
+          this.markHealthFromExecuteError(skill, err, log, entry.job_id);
+          throw err;
         } finally {
           if (budgetTimer) {
             clearTimeout(budgetTimer);
@@ -4145,11 +4204,13 @@ async function cmdStart(nameArg, options = {}) {
       }
       console.log();
     } catch (e) {
-      console.warn(`  ! Wallet error: ${e.message}
+      const message = typeof e?.message === "string" ? e.message : String(e);
+      console.warn(`  ! Wallet error: ${redactRpcUrlsInText(message)}
 `);
     }
   }
   const scriptEnv = { ...process.env };
+  delete scriptEnv.ELISYM_PASSPHRASE;
   const llmKeys = loaded.secrets.llm_api_keys ?? {};
   for (const descriptor of listLlmProviders()) {
     const secretValue = llmKeys[descriptor.id];
@@ -4703,6 +4764,9 @@ function stripRpcSecrets(raw) {
     return "[unparseable RPC URL]";
   }
 }
+function redactRpcUrlsInText(text) {
+  return text.replace(/https?:\/\/[^\s)'"]+/g, (url) => stripRpcSecrets(url));
+}
 async function resolveMediaField(value, agentDir, cache, blossom, identity, onCacheUpdate) {
   if (!value) {
     return void 0;