@toon-protocol/client-mcp 0.1.0 → 0.3.0

package/dist/{chunk-3NAWISI5.js → chunk-QFHCXJ2V.js}

@@ -13,10 +13,7 @@ import {
   isEventExpired,
   parseIlpPeerInfo,
   readConfigFile
-} from "./chunk-5KFXUT5Q.js";
-import {
-  startManagedAnonProxy
-} from "./chunk-SKQTKZIH.js";
+} from "./chunk-CQ2QIZ6Z.js";
 import {
   __require
 } from "./chunk-F22GNSF6.js";
@@ -33,10 +30,12 @@ function hasConfiguredIdentity(file) {
   );
 }
 var CONFIG_HELP = {
-  transport: "Point btpUrl/relayUrl at your apex. For an .anyone hidden service use ws://<host>.anyone:3000/btp + ws://<host>.anyone:7100 \u2014 the daemon auto-routes through a managed anon proxy. For a direct apex use ws://<host>:3000/btp + ws://<host>:7100.",
-  btpUrl: "REQUIRED. BTP WebSocket URL of the apex/connector for paid writes.",
+  transport: "Configure ONE uplink for paid writes: either `proxyUrl` (connector payment-proxy over ILP-over-HTTP, e.g. https://proxy.devnet.toonprotocol.dev) OR `btpUrl` (BTP WebSocket, e.g. ws://<host>:3000/btp). Reads are always free over relayUrl.",
+  proxyUrl: "Connector-proxy base URL (deployed devnet/testnet edge). When set, paid writes route through `POST /ilp` and no BTP socket is needed. Set `destination` to the apex ILP address (e.g. g.proxy for devnet).",
+  faucetUrl: "Devnet faucet base URL (e.g. https://faucet.devnet.toonprotocol.dev) used to drip test funds before publishing.",
+  btpUrl: "BTP WebSocket URL of the apex/connector for paid writes. Optional when `proxyUrl` is set.",
   relayUrl: "Town relay WebSocket URL for FREE reads. Default ws://localhost:7100.",
-  managedAnonProxy: "Optional override \u2014 leave unset to auto-infer from btpUrl (.anyone host \u2192 managed anon proxy, anything else \u2192 direct).",
+  destination: "Default ILP publish destination (apex address). Default g.townhouse.town; set to g.proxy for the deployed devnet proxy.",
   keystorePath: "Auto-generated encrypted identity. Do not hand-edit; back up your seed phrase."
 };
 async function scaffoldFirstRun(opts = {}) {
@@ -75,13 +74,14 @@ async function scaffoldFirstRun(opts = {}) {
   if (!existsSync(configPath)) {
     updated = {
       _help: CONFIG_HELP,
+      proxyUrl: "",
       btpUrl: "",
       relayUrl: "ws://localhost:7100",
       ...updated
     };
     changed = true;
     log(
-      `[toon-clientd] wrote starter config at ${configPath} \u2014 set "btpUrl" to your apex before publishing.`
+      `[toon-clientd] wrote starter config at ${configPath} \u2014 set "proxyUrl" (connector proxy, ILP-over-HTTP) or "btpUrl" (BTP) to your apex before publishing.`
     );
   }
   if (changed) writeConfigFile(configPath, updated);
@@ -124,7 +124,6 @@ var DEFAULT_MAX_MS = 3e4;
 var noop = () => void 0;
 var RelaySubscription = class {
   relayUrl;
-  socksProxy;
   bufferSize;
   reconnectBaseMs;
   reconnectMaxMs;
@@ -147,12 +146,11 @@ var RelaySubscription = class {
   reconnectTimer = null;
   constructor(opts) {
     this.relayUrl = opts.relayUrl;
-    this.socksProxy = opts.socksProxy;
     this.bufferSize = opts.bufferSize ?? DEFAULT_BUFFER;
     this.reconnectBaseMs = opts.reconnectBaseMs ?? DEFAULT_BASE_MS;
     this.reconnectMaxMs = opts.reconnectMaxMs ?? DEFAULT_MAX_MS;
     this.log = opts.logger ?? noop;
-    this.wsFactory = opts.wsFactory ?? defaultWebSocketFactory(this.socksProxy);
+    this.wsFactory = opts.wsFactory ?? defaultWebSocketFactory();
     this.decodeEvent = opts.decodeEvent;
     this.onEvent = opts.onEvent;
   }
@@ -255,7 +253,7 @@ var RelaySubscription = class {
   }
   scheduleReconnect() {
     if (this.closing || this.reconnectTimer) return;
-    const delay2 = Math.min(
+    const delay3 = Math.min(
       this.reconnectMaxMs,
       this.reconnectBaseMs * 2 ** this.reconnectAttempts
     );
@@ -263,7 +261,7 @@ var RelaySubscription = class {
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       if (!this.closing) this.open();
-    }, delay2);
+    }, delay3);
     this.reconnectTimer.unref?.();
   }
   sendReq(subId, filters) {
@@ -347,15 +345,10 @@ function toText(data) {
 function errMsg(err) {
   return err instanceof Error ? err.message : String(err);
 }
-function defaultWebSocketFactory(socksProxy) {
+function defaultWebSocketFactory() {
   return (url) => {
     const WebSocketImpl = nodeRequire("ws");
-    let agent;
-    if (socksProxy) {
-      const { SocksProxyAgent } = nodeRequire("socks-proxy-agent");
-      agent = new SocksProxyAgent(socksProxy);
-    }
-    return new WebSocketImpl(url, agent ? { agent } : void 0);
+    return new WebSocketImpl(url);
   };
 }
 
@@ -1304,6 +1297,7 @@ var ApexDiscoveryError = class extends Error {
     this.retryable = retryable;
     this.name = "ApexDiscoveryError";
   }
+  retryable;
 };
 async function discoverApex(params) {
   const { relay, ilpAddress, pubkey, chain, childPeers } = params;
@@ -1403,7 +1397,6 @@ var ClientRunner = class {
   config;
   createClient;
   createRelay;
-  startReadProxy;
   log;
   targetsPath;
   startedAt = Date.now();
@@ -1423,9 +1416,6 @@ var ClientRunner = class {
   subIdCounter = 0;
   defaultBtpUrl;
   defaultRelayUrl;
-  /** Teardown for the daemon-managed read proxy (btp-direct + relay-`.anyone`). */
-  stopReadProxy;
-  readProxyError;
   stopped = false;
   started = false;
   constructor(deps) {
@@ -1437,17 +1427,12 @@ var ClientRunner = class {
     this.defaultRelayUrl = deps.config.relayUrl;
     this.createRelay = deps.createRelay ?? ((opts) => new RelaySubscription({
       relayUrl: opts.relayUrl,
-      ...opts.socksProxy ? { socksProxy: opts.socksProxy } : {},
       ...opts.logger ? { logger: opts.logger } : {},
       onEvent: opts.onEvent,
       // The TOON relay sends events TOON-encoded (text) on reads, not JSON.
       decodeEvent: (raw) => decodeEventFromToon(new TextEncoder().encode(raw))
     }));
-    this.startReadProxy = deps.startReadProxy ?? ((opts) => startManagedAnonProxy({
-      socksPort: opts.socksPort,
-      ...opts.log ? { log: opts.log } : {}
-    }));
-    this.registerRelay(this.defaultRelayUrl, this.config.socksProxy);
+    this.registerRelay(this.defaultRelayUrl);
     const defaultApex = this.makeApex({
       btpUrl: this.defaultBtpUrl,
       client: this.createClient(this.config.toonClientConfig),
@@ -1469,13 +1454,13 @@ var ClientRunner = class {
   start() {
     if (this.started) return;
     this.started = true;
-    if (this.config.manageReadProxy) void this.bringUpReadProxy();
     for (const relay of this.relays.values()) relay.start();
     void this.bootstrap();
     this.replayPersistedTargets();
   }
   /** Await the default apex's bootstrap (kicking it off if not already running). */
   bootstrap() {
+    if (!this.config.hasUplink) return Promise.resolve();
     const apex = this.apexes.get(this.defaultBtpUrl);
     if (!apex) return Promise.resolve();
     return this.bootstrapApex(apex);
@@ -1486,12 +1471,11 @@ var ClientRunner = class {
    * merged buffer and replaying active fan-out subscriptions. Does NOT start the
    * socket — callers start it (so construction stays side-effect-free for tests).
    */
-  registerRelay(relayUrl, socksProxy) {
+  registerRelay(relayUrl) {
     const existing = this.relays.get(relayUrl);
     if (existing) return existing;
     const relay = this.createRelay({
       relayUrl,
-      ...socksProxy ? { socksProxy } : {},
       logger: this.log,
       onEvent: (subId, event) => this.pushMerged(relayUrl, subId, event)
     });
@@ -1501,17 +1485,11 @@ var ClientRunner = class {
     return relay;
   }
   /**
-   * Add a relay read target at runtime. `.anyone` relays reuse the managed read
-   * proxy (started here if needed). Persisted unless `persist` is false.
+   * Add a relay read target at runtime. Persisted unless `persist` is false.
    */
   async addRelay(relayUrl, persist = true) {
     if (this.relays.has(relayUrl)) return;
-    let socksProxy = this.config.socksProxy;
-    if (isAnyoneHost(relayUrl) && !socksProxy) {
-      await this.ensureReadProxy();
-      socksProxy = `socks5h://127.0.0.1:${this.config.readProxySocksPort ?? 9050}`;
-    }
-    const relay = this.registerRelay(relayUrl, socksProxy);
+    const relay = this.registerRelay(relayUrl);
     relay.start();
     if (persist) saveRelayTarget(relayUrl, this.targetsPath);
   }
@@ -1558,6 +1536,24 @@ var ClientRunner = class {
     for (const url of targets) this.relays.get(url)?.subscribe(filters, subId);
     return { subId, relays: targets };
   }
+  /**
+   * One-shot free read: subscribe the given filter(s) across all relays, wait a
+   * bounded window for the relay(s) to deliver, then return every buffered event
+   * matching the filter (matched by content, not subId — so events already
+   * buffered by other subscriptions are included despite the global dedup).
+   *
+   * Backs the apps `toon_query` tool the generative-UI runtime calls to resolve
+   * a ViewSpec node's data bind.
+   */
+  async query(filters, timeoutMs = 1200) {
+    const list = Array.isArray(filters) ? filters : [filters];
+    const subId = `q-${++this.subIdCounter}`;
+    const targets = [...this.relays.keys()];
+    for (const url of targets) this.relays.get(url)?.subscribe(list, subId);
+    await delay2(timeoutMs);
+    for (const url of targets) this.relays.get(url)?.unsubscribe(subId);
+    return this.merged.map((m) => m.event).filter((event) => list.some((f) => matchesFilter(event, f)));
+  }
   /** Drain merged events newer than the cursor (free read), optionally scoped. */
   getEvents(query) {
     const after = query.cursor ?? 0;
@@ -1597,14 +1593,20 @@ var ClientRunner = class {
   async doBootstrapApex(apex) {
     apex.bootstrapping = true;
     try {
+      if (!apex.negotiation && this.config.proxyUrl) {
+        await this.discoverApexNegotiation(apex);
+      }
       await apex.client.start();
       this.injectApexNegotiation(apex);
-      apex.apexChannelId = await this.openOrResumeApexChannel(apex);
+      const deferOpen = Boolean(this.config.proxyUrl);
+      apex.apexChannelId = await this.openOrResumeApexChannel(apex, {
+        resumeOnly: deferOpen
+      });
       this.routeChildPeersThroughApexChannel(apex);
       apex.ready = true;
       apex.lastError = void 0;
       this.log(
-        `[runner] apex ${apex.btpUrl} ready; channel ${apex.apexChannelId}`
+        `[runner] apex ${apex.btpUrl || apex.destination} ready; channel ${apex.apexChannelId ?? "(deferred \u2014 open on first write)"}`
       );
     } catch (err) {
       apex.lastError = err instanceof Error ? err.message : String(err);
@@ -1733,37 +1735,15 @@ var ClientRunner = class {
       );
     }
   }
-  // ── Shared read proxy ──────────────────────────────────────────────────────
-  async ensureReadProxy() {
-    if (this.stopReadProxy) return;
-    await this.bringUpReadProxy();
-  }
-  async bringUpReadProxy() {
-    if (this.stopReadProxy) return;
-    const socksPort = this.config.readProxySocksPort ?? 9050;
-    try {
-      this.log(
-        `[runner] starting managed read proxy on 127.0.0.1:${socksPort}`
-      );
-      const proxy = await this.startReadProxy({
-        socksPort,
-        log: (m) => this.log(`[anon] ${m}`)
-      });
-      if (this.stopped) {
-        await proxy.stop();
-        return;
-      }
-      this.stopReadProxy = () => proxy.stop();
-      this.readProxyError = void 0;
-      this.log("[runner] managed read proxy ready");
-    } catch (err) {
-      this.readProxyError = err instanceof Error ? err.message : String(err);
-      this.log(`[runner] managed read proxy failed: ${this.readProxyError}`);
-    }
-  }
   // ── Channel / negotiation helpers (per-apex) ───────────────────────────────
-  /** Open the apex channel — or, on a restart, RESUME the existing one. */
-  async openOrResumeApexChannel(apex) {
+  /**
+   * Open the apex channel — or, on a restart, RESUME the existing one.
+   *
+   * With `resumeOnly`, only a persisted channel is resumed (no on-chain open);
+   * returns undefined when none exists so the caller can defer the open to the
+   * first write (funded-after-start demo flow, #69).
+   */
+  async openOrResumeApexChannel(apex, opts = {}) {
     const { destination, chain } = apex;
     const { apexChannelStorePath } = this.config;
     const saved = loadApexChannel(apexChannelStorePath, destination, chain);
@@ -1775,10 +1755,24 @@ var ClientRunner = class {
       );
       return saved.channelId;
     }
+    if (opts.resumeOnly) return void 0;
     const channelId = await apex.client.openChannel(destination);
-    if (apex.negotiation) {
-      const a = apex.negotiation;
-      saveApexChannel(apexChannelStorePath, destination, chain, {
+    this.persistApexChannel(apex, channelId);
+    return channelId;
+  }
+  /**
+   * Persist a (lazily- or eagerly-) opened apex channel so a restart RESUMES it
+   * (tracked, no re-deposit) rather than opening a second on-chain channel.
+   * No-op when the apex carries no negotiation (nothing to key the store on).
+   */
+  persistApexChannel(apex, channelId) {
+    const a = apex.negotiation;
+    if (!a) return;
+    saveApexChannel(
+      this.config.apexChannelStorePath,
+      apex.destination,
+      apex.chain,
+      {
         channelId,
         context: {
           chainType: a.chain,
@@ -1787,9 +1781,34 @@ var ClientRunner = class {
           ...a.tokenAddress ? { tokenAddress: a.tokenAddress } : {},
           recipient: a.settlementAddress
         }
-      });
+      }
+    );
+  }
+  /**
+   * Discover the apex's settlement negotiation from its kind:10032 on the
+   * default relay and attach it to the apex (proxy-mode fallback when no config
+   * negotiation was supplied, #69). Throws ApexDiscoveryError on timeout/missing
+   * settlement params so the apex's `lastError` reports exactly what is missing.
+   */
+  async discoverApexNegotiation(apex) {
+    const relay = this.relays.get(this.defaultRelayUrl);
+    if (!relay) {
+      throw new TargetError(
+        `Cannot discover apex "${apex.destination}": default relay ${this.defaultRelayUrl} is not registered.`
+      );
     }
-    return channelId;
+    relay.start();
+    const discovered = await discoverApex({
+      relay,
+      ilpAddress: apex.destination,
+      chain: apex.chain,
+      ...apex.childPeers.length > 0 ? { childPeers: apex.childPeers } : {}
+    });
+    apex.negotiation = discovered.negotiation;
+    if (discovered.apexChildPeers) apex.childPeers = discovered.apexChildPeers;
+    this.log(
+      `[runner] discovered apex negotiation for "${apex.destination}" (chain ${discovered.negotiation.chainKey}, settle ${discovered.negotiation.settlementAddress})`
+    );
   }
   /** Inject the apex settlement negotiation directly into its ToonClient. */
   injectApexNegotiation(apex) {
@@ -1873,16 +1892,14 @@ var ClientRunner = class {
         minaAddress: safe(() => client?.getMinaAddress())
       },
       transport: {
-        type: this.config.socksProxy ? "socks5" : "direct",
-        ...this.config.socksProxy ? { socksProxy: this.config.socksProxy } : {},
+        type: "direct",
         ...apex ? { btpUrl: apex.btpUrl } : {}
       },
       relay: {
         url: this.defaultRelayUrl,
         connected: relay?.isConnected() ?? false,
         buffered: relay?.bufferedCount() ?? 0,
-        subscriptions: relay?.activeSubscriptions() ?? [],
-        ...this.readProxyError ? { proxyError: this.readProxyError } : {}
+        subscriptions: relay?.activeSubscriptions() ?? []
       },
       ...network ? { network } : {},
       ...apex?.lastError ? { lastError: apex.lastError } : {}
@@ -1916,7 +1933,14 @@ var ClientRunner = class {
   async publish(req) {
     const apex = this.selectApex(req.btpUrl);
     this.assertApexReady(apex);
-    const channelId = apex.apexChannelId ?? await apex.client.openChannel(req.destination);
+    let channelId = apex.apexChannelId;
+    if (!channelId) {
+      channelId = await apex.client.openChannel(req.destination);
+      if (!req.destination || req.destination === apex.destination) {
+        apex.apexChannelId = channelId;
+        this.persistApexChannel(apex, channelId);
+      }
+    }
     const fee = req.fee !== void 0 ? BigInt(req.fee) : apex.feePerEvent;
     const claim = await apex.client.signBalanceProof(channelId, fee);
     const result = await apex.client.publishEvent(req.event, {
@@ -1934,6 +1958,104 @@ var ClientRunner = class {
       nonce: apex.client.getChannelNonce(channelId)
     };
   }
+  /**
+   * Build, sign (with the daemon-held key), and pay-to-write an event. The
+   * caller supplies only the event shell; the private key never leaves the
+   * daemon. Payloads are MODEL-AUTHORED → validated server-side here (the model
+   * is not a security boundary). Replaceable kinds (0/3) merge the latest known
+   * event's tags before signing.
+   */
+  async publishUnsigned(req) {
+    const apex = this.selectApex(req.btpUrl);
+    this.assertApexReady(apex);
+    const template = this.buildTemplate(apex, req);
+    const signed = await apex.client.signEvent(template);
+    return this.publish({
+      event: signed,
+      ...req.destination ? { destination: req.destination } : {},
+      ...req.fee ? { fee: req.fee } : {},
+      ...req.btpUrl ? { btpUrl: req.btpUrl } : {}
+    });
+  }
+  /**
+   * Upload media to Arweave (kind:5094 blob DVM, single-packet) then sign+publish
+   * a media event referencing the resulting URL. One spendy operation, two steps,
+   * entirely server-side.
+   */
+  async uploadMedia(req) {
+    const apex = this.selectApex(req.btpUrl);
+    this.assertApexReady(apex);
+    if (typeof req.dataBase64 !== "string" || req.dataBase64 === "") {
+      throw new InvalidPayloadError("dataBase64 (base64 media bytes) is required.");
+    }
+    const blobData = new Uint8Array(Buffer.from(req.dataBase64, "base64"));
+    const fee = req.fee !== void 0 ? BigInt(req.fee) : apex.feePerEvent;
+    const upload = await apex.client.uploadBlob({
+      blobData,
+      ...req.mime ? { contentType: req.mime } : {},
+      ilpAmount: fee
+    });
+    if (!upload.success || !upload.txId) {
+      throw new PublishRejectedError(upload.error ?? "blob upload rejected");
+    }
+    const url = `${ARWEAVE_GATEWAY}/${upload.txId}`;
+    const kind = req.kind ?? 1063;
+    const signed = await apex.client.signEvent({
+      kind,
+      created_at: nowSeconds(),
+      tags: this.buildMediaTags(kind, url, req),
+      content: req.caption ?? ""
+    });
+    const pub = await this.publish({
+      event: signed,
+      ...req.fee ? { fee: req.fee } : {},
+      ...req.btpUrl ? { btpUrl: req.btpUrl } : {}
+    });
+    return { ...pub, url, txId: upload.txId };
+  }
+  /** Validate + assemble a signable event template (with replaceable merge). */
+  buildTemplate(apex, req) {
+    if (!Number.isInteger(req.kind) || req.kind < 0 || req.kind > 65535) {
+      throw new InvalidPayloadError("kind must be an integer in [0, 65535].");
+    }
+    if (req.content !== void 0 && typeof req.content !== "string") {
+      throw new InvalidPayloadError("content must be a string.");
+    }
+    const tags = normalizeTags(req.tags);
+    const content = req.content ?? "";
+    if (req.kind === 0 || req.kind === 3) {
+      const prior = this.latestSelfReplaceable(apex, req.kind);
+      if (prior) {
+        return {
+          kind: req.kind,
+          created_at: nowSeconds(),
+          tags: mergeTags(prior.tags, tags),
+          content: content !== "" ? content : prior.content
+        };
+      }
+    }
+    return { kind: req.kind, created_at: nowSeconds(), tags, content };
+  }
+  /** Latest self-authored event of `kind` currently in the merged read buffer. */
+  latestSelfReplaceable(apex, kind) {
+    const pubkey = safe(() => apex.client.getPublicKey());
+    if (!pubkey) return void 0;
+    let latest;
+    for (const m of this.merged) {
+      if (m.event.kind !== kind || m.event.pubkey !== pubkey) continue;
+      if (!latest || m.event.created_at > latest.created_at) latest = m.event;
+    }
+    return latest;
+  }
+  /** Tags for a published media event referencing an Arweave URL. */
+  buildMediaTags(kind, url, req) {
+    const mime = req.mime ?? "application/octet-stream";
+    const extra = normalizeTags(req.tags);
+    if (kind === 1063) {
+      return [["url", url], ["m", mime], ...extra];
+    }
+    return [["imeta", `url ${url}`, `m ${mime}`], ...extra];
+  }
   /** Open (or return) a payment channel on the selected (or default) apex. */
   async openChannel(destination, btpUrl) {
     const apex = this.selectApex(btpUrl);
@@ -1942,7 +2064,9 @@ var ClientRunner = class {
       destination ?? apex.destination
     );
     if (!destination || destination === apex.destination) {
+      const firstOpen = apex.apexChannelId !== channelId;
       apex.apexChannelId = channelId;
+      if (firstOpen) this.persistApexChannel(apex, channelId);
     }
     return { channelId };
   }
@@ -1999,19 +2123,31 @@ var ClientRunner = class {
       ...firstReject ? { code: firstReject.code, message: firstReject.message } : {}
     };
   }
-  /** Graceful teardown: close every relay + stop every apex client + read proxy. */
+  /**
+   * Payment-aware HTTP fetch through an apex's client. The client issues the
+   * request and, on `402 Payment Required`, pays over TOON and retries; we
+   * translate the resulting Web `Response` into the wire envelope.
+   */
+  async httpFetchPaid(req) {
+    const apex = this.selectApex();
+    this.assertApexReady(apex);
+    const res = await apex.client.h402Fetch(req.url, {
+      ...req.method ? { method: req.method } : {},
+      ...req.headers ? { headers: req.headers } : {},
+      ...req.body !== void 0 ? { body: req.body } : {},
+      ...req.timeout !== void 0 ? { timeout: req.timeout } : {}
+    });
+    return {
+      status: res.status,
+      headers: Object.fromEntries(res.headers.entries()),
+      body: await res.text()
+    };
+  }
+  /** Graceful teardown: close every relay + stop every apex client. */
   async stop() {
     if (this.stopped) return;
     this.stopped = true;
     for (const relay of this.relays.values()) relay.close();
-    if (this.stopReadProxy) {
-      try {
-        await this.stopReadProxy();
-      } catch (err) {
-        this.log(`[runner] read proxy stop error: ${errMsg2(err)}`);
-      }
-      this.stopReadProxy = void 0;
-    }
     for (const apex of this.apexes.values()) {
       try {
         await apex.client.stop();
@@ -2032,9 +2168,14 @@ var ClientRunner = class {
     return def;
   }
   assertApexReady(apex) {
+    if (!this.config.hasUplink) {
+      throw new TargetError(
+        "No write uplink configured \u2014 this daemon is read-only. Set TOON_CLIENT_PROXY_URL (connector proxy) or TOON_CLIENT_BTP_URL to enable paid writes."
+      );
+    }
     if (!apex.ready) {
       throw new NotReadyError(
-        apex.bootstrapping ? "Apex is still bootstrapping (BTP/anon coming up) \u2014 retry shortly." : apex.lastError ?? "Apex is not ready."
+        apex.bootstrapping ? "Apex is still bootstrapping (transport/channel coming up) \u2014 retry shortly." : apex.lastError ?? "Apex is not ready."
       );
     }
   }
@@ -2058,6 +2199,57 @@ var TargetError = class extends Error {
     this.name = "TargetError";
   }
 };
+var InvalidPayloadError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidPayloadError";
+  }
+};
+var ARWEAVE_GATEWAY = "https://arweave.net";
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function matchesFilter(event, filter) {
+  if (filter.ids && !filter.ids.includes(event.id)) return false;
+  if (filter.kinds && !filter.kinds.includes(event.kind)) return false;
+  if (filter.authors && !filter.authors.includes(event.pubkey)) return false;
+  if (filter.since !== void 0 && event.created_at < filter.since) return false;
+  if (filter.until !== void 0 && event.created_at > filter.until) return false;
+  for (const [key2, values] of Object.entries(filter)) {
+    if (!key2.startsWith("#") || !Array.isArray(values)) continue;
+    const letter = key2.slice(1);
+    const hit = event.tags.some(
+      (t) => t[0] === letter && t[1] !== void 0 && values.includes(t[1])
+    );
+    if (!hit) return false;
+  }
+  return true;
+}
+function normalizeTags(raw) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw)) throw new InvalidPayloadError("tags must be an array.");
+  return raw.map((tag, i) => {
+    if (!Array.isArray(tag) || !tag.every((x) => typeof x === "string")) {
+      throw new InvalidPayloadError(`tags[${i}] must be an array of strings.`);
+    }
+    return tag;
+  });
+}
+function mergeTags(base, additions) {
+  const seen = new Set(base.map((t) => JSON.stringify(t)));
+  const out = [...base];
+  for (const tag of additions) {
+    const key2 = JSON.stringify(tag);
+    if (!seen.has(key2)) {
+      seen.add(key2);
+      out.push(tag);
+    }
+  }
+  return out;
+}
 function safe(fn) {
   try {
     return fn();
@@ -2071,13 +2263,6 @@ function errMsg2(err) {
 function sanitize(s) {
   return s.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
 }
-function isAnyoneHost(url) {
-  try {
-    return new URL(url).hostname.endsWith(".anyone");
-  } catch {
-    return false;
-  }
-}
 
 // src/daemon/routes.ts
 function registerRoutes(app, runner) {
@@ -2095,6 +2280,49 @@ function registerRoutes(app, runner) {
       return mapError(reply, err);
     }
   });
+  app.post(
+    "/publish-unsigned",
+    async (req, reply) => {
+      const body = req.body;
+      if (!body || !Number.isInteger(body.kind)) {
+        return sendError(reply, 400, "invalid_event", {
+          detail: "body.kind (integer) is required; the daemon signs the event."
+        });
+      }
+      try {
+        return await runner.publishUnsigned(body);
+      } catch (err) {
+        return mapError(reply, err);
+      }
+    }
+  );
+  app.post("/upload-media", async (req, reply) => {
+    const body = req.body;
+    if (!body || typeof body.dataBase64 !== "string" || body.dataBase64 === "") {
+      return sendError(reply, 400, "invalid_media", {
+        detail: "body.dataBase64 (base64-encoded media bytes) is required."
+      });
+    }
+    try {
+      return await runner.uploadMedia(body);
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
+  app.post("/query", async (req, reply) => {
+    const body = req.body;
+    if (!body || body.filters === void 0) {
+      return sendError(reply, 400, "invalid_filters", {
+        detail: "body.filters is required (a NIP-01 filter or array of filters)."
+      });
+    }
+    try {
+      const events = await runner.query(body.filters, body.timeoutMs);
+      return { events };
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
   app.post("/subscribe", async (req, reply) => {
     const body = req.body;
     if (!body || body.filters === void 0) {
@@ -2138,6 +2366,22 @@ function registerRoutes(app, runner) {
       return mapError(reply, err);
     }
   });
+  app.post(
+    "/http-fetch-paid",
+    async (req, reply) => {
+      const body = req.body;
+      if (!body || typeof body.url !== "string" || body.url === "") {
+        return sendError(reply, 400, "invalid_url", {
+          detail: "body.url (absolute resource URL) is required."
+        });
+      }
+      try {
+        return await runner.httpFetchPaid(body);
+      } catch (err) {
+        return mapError(reply, err);
+      }
+    }
+  );
   app.get("/targets", async () => runner.getTargets());
   app.post("/relays", async (req, reply) => {
     const url = req.body?.relayUrl;
@@ -2207,6 +2451,9 @@ function mapError(reply, err) {
       retryable: true
     });
   }
+  if (err instanceof InvalidPayloadError) {
+    return sendError(reply, 400, "invalid_payload", { detail: err.message });
+  }
   if (err instanceof PublishRejectedError) {
     return sendError(reply, 502, "rejected", { detail: err.message });
   }
@@ -2242,4 +2489,4 @@ export {
   PublishRejectedError,
   registerRoutes
 };
-//# sourceMappingURL=chunk-3NAWISI5.js.map
+//# sourceMappingURL=chunk-QFHCXJ2V.js.map