@elisym/cli 0.21.3 → 0.22.1

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env -S node --no-deprecation
 import { ReadableStream } from 'node:stream/web';
 import { readFileSync, existsSync, readdirSync, statSync, renameSync, chmodSync, mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve, basename, relative, sep } from 'node:path';
-import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, ElisymClient, MediaService, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, makeCensor, DEFAULT_REDACT_PATHS, POLICY_T_TAG, createSlidingWindowLimiter, getProtocolProgramId, getProtocolConfig, utf8ByteLength, LIMITS, calculateProtocolFee, decodeJobPayload, BoundedSet, KIND_JOB_FEEDBACK, NATIVE_SOL } from '@elisym/sdk';
+import { dirname, join, resolve, basename, relative, sep, extname } from 'node:path';
+import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, ElisymClient, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, createBlossomTransport, makeCensor, DEFAULT_REDACT_PATHS, POLICY_T_TAG, createSlidingWindowLimiter, getProtocolProgramId, getProtocolConfig, utf8ByteLength, LIMITS, readAcceptedTransports, calculateProtocolFee, decodeJobPayload, BoundedSet, KIND_JOB_FEEDBACK, NATIVE_SOL } from '@elisym/sdk';
 import { ElisymYamlSchema, resolveInHome, resolveInProject, createAgentDir, writeYamlInitial, writeExampleSkillTemplate, writeSecrets, listAgents, loadAgent, writeYaml, agentPaths, readMediaCache, loadPoliciesFromDir, ensureGitignoreHasIrohEntry, lookupCachedUrl, newCacheEntry, writeMediaCache } from '@elisym/sdk/agent-store';
 import { isAddress, createSolanaRpc, address } from '@solana/kit';
 import { generateSecretKey, getPublicKey, nip19, verifyEvent } from 'nostr-tools';
@@ -14,7 +14,7 @@ import { createIrohTransport } from '@elisym/sdk/node';
 import { lookup } from 'node:dns/promises';
 import { Socket } from 'node:net';
 import pino from 'pino';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { readFile, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import pLimit from 'p-limit';
 import { parseSkillMd, validateSkillFrontmatter, resolveInsidePath, DEFAULT_SCRIPT_TIMEOUT_MS, DynamicScriptSkill as DynamicScriptSkill$1, StaticScriptSkill as StaticScriptSkill$1, StaticFileSkill as StaticFileSkill$1, ScriptSkill as ScriptSkill$1 } from '@elisym/sdk/skills';
@@ -2051,6 +2051,18 @@ function createLogger(options = {}) {
     bannerLog: logWithIndent
   };
 }
+var MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif"
+};
+function mimeFromPath(path) {
+  return MIME_BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
 var payment = new SolanaPaymentStrategy();
 var LEDGER_GC_INTERVAL_MS = 60 * 60 * 1e3;
 var LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -2140,7 +2152,7 @@ var PAID_GLOBAL_MAX_JOBS_PER_WINDOW = 2e3;
 var MAX_TRACKED_CUSTOMERS = 1e3;
 var GLOBAL_LIMITER_KEY = "__global__";
 var AgentRuntime = class {
-  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}, healthMonitor, irohTransport) {
+  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}, healthMonitor, irohTransport, identity, blossomTransport) {
     this.transport = transport;
     this.skills = skills;
     this.skillCtx = skillCtx;
@@ -2149,6 +2161,8 @@ var AgentRuntime = class {
     this.callbacks = callbacks;
     this.healthMonitor = healthMonitor;
     this.irohTransport = irohTransport;
+    this.identity = identity;
+    this.blossomTransport = blossomTransport;
     this.limit = pLimit(config.maxConcurrentJobs);
     this.maxQueueSize = config.maxQueueSize ?? config.maxConcurrentJobs * 10;
   }
@@ -2576,7 +2590,7 @@ var AgentRuntime = class {
       );
       this.callbacks.onPaymentReceived?.(job.jobId, netAmount);
     }
-    const inputFile = await this.resolveInputFile(job.attachment);
+    const inputFile = await this.resolveInputFile(job.attachment, job.customerId);
     await this.transport.sendFeedback(job, { type: "processing" }).catch(() => {
     });
     const skill = this.skills.route(job.tags);
@@ -2646,7 +2660,12 @@ var AgentRuntime = class {
         });
       }
     }
-    const { attachment, deliveredContent } = await this.buildResultAttachment(job.jobId, output);
+    const { attachment, deliveredContent } = await this.buildResultAttachment(
+      job.jobId,
+      output,
+      job.customerId,
+      readAcceptedTransports(job.rawEvent.tags)
+    );
     this.ledger.markExecuted(job.jobId, deliveredContent);
     log(`[${job.jobId.slice(0, 8)}] Skill completed, delivering result`);
     const eventId = await this.transport.deliverResult(
@@ -2673,18 +2692,30 @@ var AgentRuntime = class {
    * recovery re-executes (rather than re-delivering a dead ticket). Runs after the
    * `skill.execute` budget window, so a slow seed never trips `max_execution_secs`.
    */
-  async buildResultAttachment(jobId, output) {
+  async buildResultAttachment(jobId, output, customerPubkey, acceptedTransports) {
+    const wantBlossom = acceptedTransports === void 0 || acceptedTransports.includes("blossom");
     if (output.filePath !== void 0) {
       try {
         if (!this.irohTransport) {
           throw new Error("Skill produced a file result but iroh transport is unavailable.");
         }
         const seeded = await this.irohTransport.seedPath(output.filePath);
+        const transports = [{ kind: "iroh", ticket: seeded.ticket }];
+        if (wantBlossom) {
+          const blossomMember = await this.seedBlossomFromPath(
+            output.filePath,
+            seeded.size,
+            customerPubkey
+          );
+          if (blossomMember !== void 0) {
+            transports.unshift(blossomMember);
+          }
+        }
         const attachment = {
           name: basename(output.filePath),
           size: seeded.size,
           mime: output.outputMime ?? "application/octet-stream",
-          transports: [{ kind: "iroh", ticket: seeded.ticket }]
+          transports
         };
         this.ledger.recordAttachment(jobId, { resultAttachment: JSON.stringify(attachment) });
         return { attachment, deliveredContent: output.data };
@@ -2697,18 +2728,60 @@ var AgentRuntime = class {
       if (!this.irohTransport) {
         throw new Error("Result is too large to deliver inline and iroh transport is unavailable.");
       }
-      const seeded = await this.irohTransport.seedBytes(Buffer.from(output.data, "utf8"));
+      const dataBytes = Buffer.from(output.data, "utf8");
+      const seeded = await this.irohTransport.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: [{ kind: "iroh", ticket: seeded.ticket }]
+        transports
       };
       this.ledger.recordAttachment(jobId, { resultAttachment: JSON.stringify(attachment) });
       return { attachment, deliveredContent: "" };
     }
     return { attachment: void 0, deliveredContent: output.data };
   }
+  /**
+   * Encrypt `bytes` to `recipientPubkey` and seed them to Blossom, returning a `blossom` transport
+   * member - or `undefined` when blossom isn't configured, the bytes exceed the encrypted cap, or the
+   * upload fails. Returning undefined (never throwing) keeps iroh as the guaranteed transport: an
+   * optional second path must never fail the job.
+   */
+  async seedBlossomMember(bytes, recipientPubkey) {
+    if (this.blossomTransport === void 0 || this.identity === void 0) {
+      return void 0;
+    }
+    if (bytes.byteLength > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+      return void 0;
+    }
+    try {
+      return await this.blossomTransport.seedBytes({ bytes, recipientPubkey });
+    } catch {
+      return void 0;
+    }
+  }
+  /** Read a file (only when within the encrypted cap, to bound memory) and seed it to Blossom. */
+  async seedBlossomFromPath(filePath, size, recipientPubkey) {
+    if (this.blossomTransport === void 0 || this.identity === void 0) {
+      return void 0;
+    }
+    if (size > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+      return void 0;
+    }
+    try {
+      const bytes = await readFile(filePath);
+      return await this.seedBlossomMember(bytes, recipientPubkey);
+    } catch {
+      return void 0;
+    }
+  }
   /**
    * Rebuild a file-result attachment for crash-recovery re-delivery: re-share the
    * blob from the persistent store to mint a fresh ticket (the original ticket's
@@ -2723,12 +2796,17 @@ var AgentRuntime = class {
       throw new Error("Cannot recover a file result: iroh transport is unavailable.");
     }
     const stored = JSON.parse(resultAttachmentJson);
-    const irohTransport = stored.transports.find((transport) => transport.kind === "iroh");
+    const irohTransport = stored.transports.find(
+      (transport) => transport.kind === "iroh"
+    );
     if (!irohTransport) {
       throw new Error("Stored result attachment has no iroh transport.");
     }
     const freshTicket = await this.irohTransport.reShare(irohTransport.ticket);
-    return { ...stored, transports: [{ kind: "iroh", ticket: freshTicket }] };
+    const transports = stored.transports.map(
+      (transport) => transport.kind === "iroh" ? { kind: "iroh", ticket: freshTicket } : transport
+    );
+    return { ...stored, transports };
   }
   /**
    * Resolve a job's file/large-text input (when it carries an attachment) via iroh.
@@ -2743,31 +2821,67 @@ 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) {
+  async resolveInputFile(attachment, senderPubkey) {
     if (attachment === void 0) {
       return void 0;
     }
-    if (!this.irohTransport) {
-      throw new Error("Job carries a file input but iroh transport is unavailable.");
-    }
-    const irohTransport = attachment.transports.find((transport) => transport.kind === "iroh");
-    if (!irohTransport) {
-      throw new Error("File input has no iroh transport.");
-    }
-    if (attachment.mime.startsWith("text/") && attachment.size <= LIMITS.MAX_REINLINE_TEXT_BYTES) {
-      const bytes = await this.irohTransport.fetchToBytes(irohTransport.ticket, {
-        maxBytes: LIMITS.MAX_REINLINE_TEXT_BYTES
-      });
+    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
+        });
+        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;
+      }
       return {
-        inlineText: Buffer.from(bytes).toString("utf8"),
+        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
+      });
+      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
+   * in-memory string; anything else is written to a fixed `input` name inside a unique mkdtemp dir
+   * (the untrusted attachment `name` never touches the path). Shared by the iroh-text and blossom
+   * paths (both have the bytes in hand); the iroh-binary path streams to disk separately.
+   */
+  async materializeBytesInput(bytes, mime) {
+    if (mime.startsWith("text/") && bytes.byteLength <= LIMITS.MAX_REINLINE_TEXT_BYTES) {
+      return { inlineText: Buffer.from(bytes).toString("utf8"), cleanup: async () => {
+      } };
+    }
     const dir = await mkdtemp(join(tmpdir(), "elisym-job-"));
     const filePath = join(dir, "input");
     try {
-      await this.irohTransport.fetchToPath(irohTransport.ticket, filePath);
+      await writeFile(filePath, bytes);
     } catch (error) {
       await rm(dir, { recursive: true, force: true }).catch(() => {
       });
@@ -3100,7 +3214,8 @@ var AgentRuntime = class {
         let recoveryInputFile;
         try {
           recoveryInputFile = await this.resolveInputFile(
-            decodeJobPayload(rawEvent.content).attachment
+            decodeJobPayload(rawEvent.content).attachment,
+            entry.customer_id
           );
         } catch {
           log(`[${entry.job_id.slice(0, 8)}] Recovery: input file unavailable, marking failed`);
@@ -3147,7 +3262,9 @@ var AgentRuntime = class {
         }
         const { attachment: resultAttachment, deliveredContent } = await this.buildResultAttachment(
           entry.job_id,
-          output
+          output,
+          entry.customer_id,
+          readAcceptedTransports(rawEvent.tags)
         );
         this.ledger.markExecuted(entry.job_id, deliveredContent);
         await this.transport.deliverResult(
@@ -4163,14 +4280,13 @@ async function cmdStart(nameArg, options = {}) {
       }
     }
   }
-  const media = new MediaService();
   const mediaCache = await readMediaCache(loaded.dir);
   let mediaCacheDirty = false;
   const pictureUrl = await resolveMediaField(
     loaded.yaml.picture,
     loaded.dir,
     mediaCache,
-    media,
+    client.blossom,
     identity,
     (updated) => mediaCacheDirty = mediaCacheDirty || updated
   );
@@ -4178,7 +4294,7 @@ async function cmdStart(nameArg, options = {}) {
     loaded.yaml.banner,
     loaded.dir,
     mediaCache,
-    media,
+    client.blossom,
     identity,
     (updated) => mediaCacheDirty = mediaCacheDirty || updated
   );
@@ -4194,7 +4310,7 @@ async function cmdStart(nameArg, options = {}) {
       cacheKey,
       absPath,
       mediaCache,
-      media,
+      client.blossom,
       identity,
       () => mediaCacheDirty = true
     );
@@ -4434,6 +4550,7 @@ async function cmdStart(nameArg, options = {}) {
     });
     diagLog("LLM health monitor armed (lazy recovery, 5min interval).");
   }
+  const blossomTransport = createBlossomTransport({ blossom: client.blossom, identity });
   const runtime = new AgentRuntime(
     transport,
     registry,
@@ -4465,7 +4582,9 @@ async function cmdStart(nameArg, options = {}) {
       }
     },
     healthMonitor,
-    irohTransport
+    irohTransport,
+    identity,
+    blossomTransport
   );
   console.log("  * Running. Press Ctrl+C to stop.\n");
   await runtime.run();
@@ -4490,7 +4609,7 @@ function stripRpcSecrets(raw) {
     return "[unparseable RPC URL]";
   }
 }
-async function resolveMediaField(value, agentDir, cache, media, identity, onCacheUpdate) {
+async function resolveMediaField(value, agentDir, cache, blossom, identity, onCacheUpdate) {
   if (!value) {
     return void 0;
   }
@@ -4502,7 +4621,7 @@ async function resolveMediaField(value, agentDir, cache, media, identity, onCach
     console.warn(`  ! Skipping media field "${value}": path must stay inside the agent directory.`);
     return void 0;
   }
-  return uploadOrReuse(value, absPath, cache, media, identity, () => onCacheUpdate(true));
+  return uploadOrReuse(value, absPath, cache, blossom, identity, () => onCacheUpdate(true));
 }
 function resolveInsideAgentDir(value, agentDir) {
   const agentRoot = resolve(agentDir);
@@ -4513,7 +4632,7 @@ function resolveInsideAgentDir(value, agentDir) {
   }
   return candidate;
 }
-async function uploadOrReuse(cacheKey, absPath, cache, media, identity, onCacheUpdate) {
+async function uploadOrReuse(cacheKey, absPath, cache, blossom, identity, onCacheUpdate) {
   try {
     const cached = await lookupCachedUrl(cache, cacheKey, absPath);
     if (cached) {
@@ -4522,12 +4641,12 @@ async function uploadOrReuse(cacheKey, absPath, cache, media, identity, onCacheU
     console.log(`  Uploading ${basename(absPath)}...`);
     const data = readFileSync(absPath);
     const sha256 = createHash("sha256").update(data).digest("hex");
-    const blob = new Blob([data]);
-    const url = await media.upload(identity, blob, basename(absPath));
-    cache[cacheKey] = newCacheEntry(url, sha256);
+    const blob = new Blob([data], { type: mimeFromPath(absPath) });
+    const descriptor = await blossom.upload(identity, blob);
+    cache[cacheKey] = newCacheEntry(descriptor.url, sha256);
     onCacheUpdate();
-    console.log(`  Uploaded: ${url}`);
-    return url;
+    console.log(`  Uploaded: ${descriptor.url}`);
+    return descriptor.url;
   } catch (e) {
     console.warn(`  ! Failed to upload ${basename(absPath)}: ${e.message}`);
     return void 0;