@toon-protocol/client-mcp 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -28,8 +28,8 @@ interface StatusResponse {
     /** Daemon process uptime, ms. */
     uptimeMs: number;
     /**
-     * True while the managed anon proxy / BTP session / channel are still coming
-     * up. Tools should surface "bootstrapping — retry" rather than blocking.
+     * True while the BTP session / channel are still coming up. Tools should
+     * surface "bootstrapping — retry" rather than blocking.
      */
     bootstrapping: boolean;
     /** True once the client has started and a channel is open (ready to publish). */
@@ -43,8 +43,7 @@ interface StatusResponse {
         minaAddress?: string;
     };
     transport: {
-        type: 'direct' | 'socks5' | 'gateway';
-        socksProxy?: string;
+        type: 'direct';
         btpUrl?: string;
     };
     relay: {
@@ -54,13 +53,6 @@ interface StatusResponse {
         buffered: number;
         /** Active subscription ids. */
         subscriptions: string[];
-        /**
-         * Error from the daemon-managed read proxy, if any. Set only in the
-         * btp-direct + relay-`.anyone` case where the daemon starts its own `anon`
-         * proxy for reads; a failure here means hidden-service reads are down while
-         * direct paid writes are unaffected.
-         */
-        proxyError?: string;
     };
     /** Per-chain settlement status when a named `network` tier is configured. */
     network?: ChainStatus[];
@@ -308,7 +300,7 @@ interface HttpFetchPaidResponse {
 }
 /** `POST /relays` — add a relay READ target (fans into all fan-out reads). */
 interface AddRelayRequest {
-    /** Relay WS URL, e.g. `ws://host:7100` or a `.anyone` hidden service. */
+    /** Relay WS URL, e.g. `ws://host:7100`. */
     relayUrl: string;
 }
 /** `DELETE /relays` — remove a relay read target. */
@@ -462,9 +454,7 @@ declare class ControlClient {
  * with exponential backoff and re-issues every active REQ on reconnect.
  *
  * The WebSocket is injectable (`wsFactory`) so unit tests can drive the wire
- * protocol without a real relay; the default factory uses the `ws` package and,
- * when a `socks5h://` proxy is configured, routes through it so `.anyone`
- * hidden-service relays are reachable.
+ * protocol without a real relay; the default factory uses the `ws` package.
  */
 
 /** Minimal WebSocket surface this module depends on (subset of `ws`). */
@@ -477,10 +467,8 @@ interface MinimalWebSocket {
 }
 type WebSocketFactory = (url: string) => MinimalWebSocket;
 interface RelaySubscriptionOptions {
-    /** Town relay WS URL, e.g. `wss://<host>.anyone/` or `ws://localhost:7100`. */
+    /** Town relay WS URL, e.g. `ws://localhost:7100`. */
     relayUrl: string;
-    /** Optional `socks5h://host:port` proxy for `.anyone` relays. */
-    socksProxy?: string;
     /** Max events retained in the ring buffer (oldest evicted). Default 5000. */
     bufferSize?: number;
     /** Base reconnect delay, ms. Default 1000. */
@@ -515,7 +503,6 @@ interface DrainResult {
 }
 declare class RelaySubscription {
     private readonly relayUrl;
-    private readonly socksProxy?;
     private readonly bufferSize;
     private readonly reconnectBaseMs;
     private readonly reconnectMaxMs;
@@ -626,12 +613,19 @@ interface DaemonConfigFile {
     _help?: Record<string, string>;
     /** BTP WebSocket URL of the apex/connector. */
     btpUrl?: string;
-    /** Transport: `direct` or a `socks5h://` proxy for `.anyone` hosts. */
-    socksProxy?: string;
-    /** Auto-manage the anon proxy for `.anyone` BTP hosts. Default true for HS. */
-    managedAnonProxy?: boolean;
-    /** Loopback SOCKS port the managed anon proxy binds (also used for reads). Default 9050. */
-    managedAnonSocksPort?: number;
+    /**
+     * Connector-PROXY base URL (devnet payment-proxy, e.g.
+     * `https://proxy.devnet.toonprotocol.dev`). When set, the daemon routes paid
+     * writes through the proxy's `POST /ilp` (ILP-over-HTTP) WITHOUT a BTP socket;
+     * `btpUrl` then becomes optional. Env override: `TOON_CLIENT_PROXY_URL`.
+     */
+    proxyUrl?: string;
+    /**
+     * Devnet faucet base URL (e.g. `https://faucet.devnet.toonprotocol.dev`),
+     * carried through to the ToonClient config for tooling/e2e funding. Env
+     * override: `TOON_CLIENT_FAUCET_URL`.
+     */
+    faucetUrl?: string;
     /** Town relay WS URL for FREE reads. */
     relayUrl?: string;
     /** Default ILP publish destination. Default `g.townhouse.town`. */
@@ -679,16 +673,17 @@ interface DaemonConfigFile {
 interface ResolvedDaemonConfig {
     httpPort: number;
     relayUrl: string;
-    socksProxy?: string;
     /**
-     * When true the daemon must start its OWN managed `anon` proxy for free reads
-     * — the btp-direct + relay-`.anyone` case the ToonClient does not cover (it
-     * only auto-starts a proxy for a `.anyone` btpUrl). `readProxySocksPort` is the
-     * loopback port to bind; `socksProxy` already points the relay at it.
+     * Whether a write uplink (proxy or BTP) is configured. FREE reads work
+     * without one; a write attempt with `hasUplink === false` is rejected at the
+     * control plane with a clear "configure an uplink" error (issue #69). Reads
+     * (`subscribe`/`query`/`getEvents`) never consult this.
      */
-    manageReadProxy: boolean;
-    /** Loopback SOCKS port for the daemon-managed read proxy (when `manageReadProxy`). */
-    readProxySocksPort?: number;
+    hasUplink: boolean;
+    /** Connector-proxy base URL (devnet payment-proxy), when configured. */
+    proxyUrl?: string;
+    /** Devnet faucet base URL, when configured. */
+    faucetUrl?: string;
     destination: string;
     feePerEvent: bigint;
     apex?: ApexNegotiationConfig;
@@ -721,8 +716,9 @@ declare function resolveMnemonic(file: DaemonConfigFile): string;
 /**
  * Build the full resolved daemon config (file overlaid with env, mnemonic
  * resolved, ToonClientConfig assembled). Env overrides supported:
- *   TOON_CLIENT_BTP_URL, TOON_CLIENT_RELAY_URL, TOON_CLIENT_SOCKS,
- *   TOON_CLIENT_HTTP_PORT, TOON_CLIENT_NETWORK.
+ *   TOON_CLIENT_BTP_URL, TOON_CLIENT_PROXY_URL, TOON_CLIENT_FAUCET_URL,
+ *   TOON_CLIENT_RELAY_URL, TOON_CLIENT_HTTP_PORT, TOON_CLIENT_NETWORK,
+ *   TOON_CLIENT_DESTINATION.
  */
 declare function resolveConfig(file: DaemonConfigFile): ResolvedDaemonConfig;
 
@@ -742,8 +738,8 @@ declare function resolveConfig(file: DaemonConfigFile): ResolvedDaemonConfig;
  * relay + apex are the permanent DEFAULT targets and cannot be removed.
  *
  * Each apex bootstraps asynchronously and non-blocking: the connection comes up
- * in the background (the managed anon proxy alone can take 30–90s). Until ready,
- * writes against it report `bootstrapping` so tools surface "retry".
+ * in the background. Until ready, writes against it report `bootstrapping` so
+ * tools surface "retry".
  */
 
 /** The subset of `ToonClient` the runner depends on. */
@@ -824,20 +820,11 @@ interface ToonClientLike {
     }): Promise<Response>;
 }
 /** A started managed proxy: just the teardown handle the runner needs. */
-interface ManagedProxyHandle {
-    stop(): Promise<void>;
-}
-/** Starts a managed `anon` read proxy on a loopback SOCKS port. */
-type StartReadProxy = (opts: {
-    socksPort: number;
-    log?: (msg: string) => void;
-}) => Promise<ManagedProxyHandle>;
 /** Builds a `ToonClient` (or a fake) for a given resolved client config. */
 type CreateClient = (config: ToonClientConfig) => ToonClientLike;
-/** Builds a `RelaySubscription` for a given relay URL + optional read proxy. */
+/** Builds a `RelaySubscription` for a given relay URL. */
 type CreateRelay = (opts: {
     relayUrl: string;
-    socksProxy?: string;
     onEvent: (subId: string, event: NostrEvent) => void;
     logger?: (msg: string) => void;
 }) => RelaySubscription;
@@ -847,11 +834,6 @@ interface ClientRunnerDeps {
     createClient: CreateClient;
     /** Factory producing a relay subscription (defaults to the real one). */
     createRelay?: CreateRelay;
-    /**
-     * Starts the daemon-managed read proxy (defaults to the real
-     * `startManagedAnonProxy`). Injected so tests avoid the anon download/spawn.
-     */
-    startReadProxy?: StartReadProxy;
     logger?: (msg: string) => void;
     /** Path to the dynamic-targets store (tests override). */
     targetsPath?: string;
@@ -860,7 +842,6 @@ declare class ClientRunner {
     private readonly config;
     private readonly createClient;
     private readonly createRelay;
-    private readonly startReadProxy;
     private readonly log;
     private readonly targetsPath?;
     private readonly startedAt;
@@ -880,9 +861,6 @@ declare class ClientRunner {
     private subIdCounter;
     private readonly defaultBtpUrl;
     private readonly defaultRelayUrl;
-    /** Teardown for the daemon-managed read proxy (btp-direct + relay-`.anyone`). */
-    private stopReadProxy;
-    private readProxyError;
     private stopped;
     private started;
     constructor(deps: ClientRunnerDeps);
@@ -901,8 +879,7 @@ declare class ClientRunner {
      */
     private registerRelay;
     /**
-     * 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.
      */
     addRelay(relayUrl: string, persist?: boolean): Promise<void>;
     /** Remove a relay read target. The config-seeded default cannot be removed. */
@@ -947,10 +924,27 @@ declare class ClientRunner {
     private deriveApexClientConfig;
     private apexChannelStorePathFor;
     private replayPersistedTargets;
-    private ensureReadProxy;
-    private bringUpReadProxy;
-    /** Open the apex channel — or, on a restart, RESUME the existing one. */
+    /**
+     * 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).
+     */
     private openOrResumeApexChannel;
+    /**
+     * 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).
+     */
+    private persistApexChannel;
+    /**
+     * 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.
+     */
+    private discoverApexNegotiation;
     /** Inject the apex settlement negotiation directly into its ToonClient. */
     private injectApexNegotiation;
     /** Route apex CHILD peers (dvm/mill) through the SAME apex payment channel. */
@@ -998,7 +992,7 @@ declare class ClientRunner {
      * translate the resulting Web `Response` into the wire envelope.
      */
     httpFetchPaid(req: HttpFetchPaidRequest): Promise<HttpFetchPaidResponse>;
-    /** Graceful teardown: close every relay + stop every apex client + read proxy. */
+    /** Graceful teardown: close every relay + stop every apex client. */
     stop(): Promise<void>;
     private selectApex;
     private assertApexReady;
@@ -1028,9 +1022,8 @@ declare class PublishRejectedError extends Error {
  *      a default password so the identity survives restarts with no env var.
  *      The mnemonic + derived addresses are printed ONCE for backup.
  *   2. **Transport scaffolding** — ensure `config.json` carries the transport
- *      knobs (`btpUrl`/`relayUrl`/`managedAnonProxy`) plus a `_help` block
- *      documenting direct-vs-`.anyone` selection, so the user can see what to
- *      point at.
+ *      knobs (`btpUrl`/`relayUrl`) plus a `_help` block documenting them, so the
+ *      user can see what to point at.
  *
  * This is all idempotent: on later runs an identity already exists, so nothing
  * is regenerated and the config is left untouched.
@@ -1097,7 +1090,8 @@ declare function spawnDaemonDetached(opts?: SpawnDaemonOptions): number;
 /**
  * Poll the control plane until the daemon answers `GET /status`, up to
  * `timeoutMs`. Resolves true once reachable (NOT necessarily done
- * bootstrapping — anon can take 30–90s; callers surface `bootstrapping`).
+ * bootstrapping — the BTP session can take a moment; callers surface
+ * `bootstrapping`).
  */
 declare function waitForReady(baseUrl: string, timeoutMs?: number, intervalMs?: number): Promise<boolean>;
 
@@ -1146,7 +1140,7 @@ interface JourneyStep {
     /** Build the tool input from accumulated prior-step state. */
     buildInput: (state: JourneyState) => Record<string, unknown>;
     /** Render the step's result data as a ViewSpec panel. */
-    renderPanel: (data: unknown) => ViewSpec;
+    renderPanel: (data: unknown, state: JourneyState) => ViewSpec;
 }
 /** Ordered sequence of steps with plan metadata. */
 interface JourneyPlan {

package/dist/index.js

@@ -8,11 +8,17 @@ import {
   hasConfiguredIdentity,
   registerRoutes,
   scaffoldFirstRun
-} from "./chunk-L6F2B3GX.js";
+} from "./chunk-QFHCXJ2V.js";
 import {
+  PUBLISH_TOOL,
   TOOL_DEFINITIONS,
+  UPLOAD_TOOL,
+  buildFeedFilter,
+  buildFileMetadataFilter,
+  buildFollowListFilter,
+  buildProfileFilter,
   dispatchTool
-} from "./chunk-KNQ2DKNN.js";
+} from "./chunk-4GWMHKPP.js";
 import {
   ControlApiError,
   ControlClient,
@@ -30,12 +36,11 @@ import {
   resolveMnemonic,
   spawnDaemonDetached,
   waitForReady
-} from "./chunk-NP35YO5O.js";
+} from "./chunk-CQ2QIZ6Z.js";
 import "./chunk-32QD72IL.js";
 import "./chunk-DLYE6U2Z.js";
 import "./chunk-LR7W2ISE.js";
 import "./chunk-VA7XC4FD.js";
-import "./chunk-SKQTKZIH.js";
 import "./chunk-F22GNSF6.js";
 
 // src/journey/runner.ts
@@ -53,7 +58,7 @@ async function runJourney(plan, client) {
     }
     const data = extractData(toolResult);
     state[step.id] = data;
-    const viewSpec = step.renderPanel(data);
+    const viewSpec = step.renderPanel(data, state);
     const panel = {
       content: [{ type: "text", text: `Journey step: ${step.id}` }],
       structuredContent: { viewSpec }
@@ -72,6 +77,340 @@ function extractData(result) {
     return text;
   }
 }
+
+// src/journey/socialfi.ts
+function pubkeyFromState(state, fallback) {
+  const onboard = state["onboard"];
+  return onboard?.identity?.nostrPubkey ?? fallback ?? "";
+}
+function socialFiJourney(opts) {
+  return {
+    id: "socialfi",
+    title: "SocialFi Journey",
+    steps: [
+      // ── Step 1: onboard ─────────────────────────────────────────────────────
+      {
+        id: "onboard",
+        toolName: "toon_status",
+        buildInput: () => ({}),
+        renderPanel: (data) => {
+          const s = data;
+          return {
+            title: "Onboard",
+            root: {
+              atom: "section",
+              props: { title: s?.ready ? "Ready to publish" : "Connecting\u2026" },
+              children: [{ atom: "card", children: [{ atom: "generic-event" }] }]
+            }
+          };
+        }
+      },
+      // ── Step 2: publish profile (kind:0) ────────────────────────────────────
+      {
+        id: "publish-profile",
+        toolName: "toon_publish_unsigned",
+        buildInput: () => ({
+          kind: 0,
+          content: JSON.stringify({ name: "TOON User", about: "Published via the SocialFi journey." })
+        }),
+        renderPanel: (_data, state) => ({
+          title: "Profile",
+          root: {
+            atom: "profile-header",
+            bind: { query: buildProfileFilter([pubkeyFromState(state, opts?.pubkey)]) }
+          }
+        })
+      },
+      // ── Step 3: publish note (kind:1) ───────────────────────────────────────
+      {
+        id: "publish-note",
+        toolName: "toon_publish_unsigned",
+        buildInput: () => ({
+          kind: 1,
+          content: "Hello from TOON Protocol!"
+        }),
+        renderPanel: (_data, state) => ({
+          title: "Note",
+          root: {
+            atom: "stack",
+            children: [
+              {
+                atom: "composer",
+                props: { placeholder: "What's happening?", label: "Post" },
+                actions: { post: { tool: PUBLISH_TOOL, args: { kind: 1 } } }
+              },
+              {
+                atom: "note-card",
+                bind: { query: buildFeedFilter([pubkeyFromState(state, opts?.pubkey)], 50), kindAuto: true }
+              }
+            ]
+          }
+        })
+      },
+      // ── Step 4: follow (kind:3) ─────────────────────────────────────────────
+      {
+        id: "follow",
+        toolName: "toon_publish_unsigned",
+        buildInput: (state) => {
+          const pubkey = pubkeyFromState(state, opts?.pubkey);
+          return { kind: 3, tags: [["p", pubkey]] };
+        },
+        renderPanel: (_data, state) => {
+          const pubkey = pubkeyFromState(state, opts?.pubkey);
+          return {
+            title: "Follow",
+            root: {
+              atom: "stack",
+              children: [
+                {
+                  atom: "follow-button",
+                  props: { label: "Follow" },
+                  actions: { follow: { tool: PUBLISH_TOOL, args: { kind: 3, tags: [["p", pubkey]] } } }
+                },
+                {
+                  atom: "note-card",
+                  bind: { query: buildFollowListFilter(pubkey), kindAuto: true }
+                }
+              ]
+            }
+          };
+        }
+      },
+      // ── Step 5: DVM upload (kind:1063) + media-embed read-back ──────────────
+      // Use toon_status (read-only) for the auto-call; the actual upload is
+      // user-initiated via the panel's media-uploader action (spendy, confirmed).
+      {
+        id: "dvm-upload",
+        toolName: "toon_status",
+        buildInput: () => ({}),
+        renderPanel: (_data, state) => ({
+          title: "Media Upload",
+          root: {
+            atom: "stack",
+            children: [
+              {
+                atom: "media-uploader",
+                props: { label: "Upload media" },
+                actions: {
+                  upload: {
+                    tool: UPLOAD_TOOL,
+                    args: { kind: 1063 },
+                    spendy: true,
+                    confirmLabel: "Upload to Arweave (spendy)"
+                  }
+                }
+              },
+              {
+                atom: "media-embed",
+                bind: { query: buildFileMetadataFilter([pubkeyFromState(state, opts?.pubkey)], 30), kindAuto: true }
+              }
+            ]
+          }
+        })
+      }
+    ]
+  };
+}
+
+// src/journey/defi.ts
+function deFiJourney(opts) {
+  let capturedSwap;
+  return {
+    id: "defi",
+    title: "DeFi Journey: Open Channel \u2192 Swap \u2192 Settlement Receipt",
+    steps: [
+      {
+        id: "open-channel",
+        toolName: "toon_open_channel",
+        buildInput: (_state) => ({ destination: opts.destination }),
+        renderPanel: (data) => {
+          const { channelId } = data;
+          return {
+            title: "Payment Channel",
+            root: {
+              atom: "stack",
+              children: [{ atom: "channel-card", props: { channelId } }]
+            }
+          };
+        }
+      },
+      {
+        id: "swap",
+        toolName: "toon_swap",
+        buildInput: (_state) => {
+          const args = {
+            destination: opts.destination,
+            amount: opts.amount,
+            millPubkey: opts.millPubkey,
+            pair: opts.pair,
+            chainRecipient: opts.chainRecipient
+          };
+          if (opts.packetCount !== void 0) {
+            args["packetCount"] = opts.packetCount;
+          }
+          return args;
+        },
+        renderPanel: (data) => {
+          capturedSwap = data;
+          return {
+            title: "Swap",
+            root: {
+              atom: "stack",
+              children: [
+                {
+                  atom: "swap-form",
+                  props: {
+                    accepted: capturedSwap.accepted,
+                    packetsAccepted: capturedSwap.packetsAccepted,
+                    cumulativeSource: capturedSwap.cumulativeSource,
+                    cumulativeTarget: capturedSwap.cumulativeTarget,
+                    state: capturedSwap.state,
+                    claims: capturedSwap.claims
+                  }
+                }
+              ]
+            }
+          };
+        }
+      },
+      {
+        id: "settlement-receipt",
+        toolName: "toon_channels",
+        buildInput: (_state) => ({}),
+        renderPanel: (data) => {
+          const { channels } = data;
+          const swap = capturedSwap;
+          return {
+            title: "Settlement Receipt",
+            root: {
+              atom: "stack",
+              children: [
+                {
+                  atom: "settlement-receipt",
+                  props: {
+                    accepted: swap?.accepted,
+                    cumulativeSource: swap?.cumulativeSource,
+                    cumulativeTarget: swap?.cumulativeTarget,
+                    claims: swap?.claims ?? [],
+                    channels
+                  }
+                }
+              ]
+            }
+          };
+        }
+      }
+    ]
+  };
+}
+
+// src/journey/demo.ts
+function chainJourneys(id, title, ...plans) {
+  const steps = plans.flatMap((p) => p.steps);
+  const seen = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (seen.has(step.id)) {
+      throw new Error(
+        `chainJourneys: duplicate step id "${step.id}" across chained plans \u2014 state threading requires unique step ids`
+      );
+    }
+    seen.add(step.id);
+  }
+  return { id, title, steps };
+}
+function capstoneJourney(opts) {
+  return chainJourneys(
+    "capstone",
+    "Capstone Journey: SocialFi \u2192 DeFi",
+    socialFiJourney(opts.socialFi),
+    deFiJourney(opts.deFi)
+  );
+}
+function extractReceipt(result) {
+  const swapStep = result.steps.find((s) => s.stepId === "swap");
+  const channelsStep = result.steps.find((s) => s.stepId === "settlement-receipt");
+  if (!swapStep || !channelsStep) return void 0;
+  const swap = parseToolText(swapStep.toolResult.content[0]?.text);
+  const channelsRes = parseToolText(
+    channelsStep.toolResult.content[0]?.text
+  );
+  if (!swap || !channelsRes) return void 0;
+  return {
+    accepted: swap.accepted,
+    state: swap.state,
+    cumulativeSource: swap.cumulativeSource,
+    cumulativeTarget: swap.cumulativeTarget,
+    claims: swap.claims ?? [],
+    channels: channelsRes.channels
+  };
+}
+function parseToolText(text) {
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+async function runCapstoneDemo(client, opts, logger = console) {
+  const plan = capstoneJourney(opts);
+  logger.log(`
+=== ${plan.title} (${plan.steps.length} steps) ===
+`);
+  const result = await runJourney(plan, client);
+  for (const step of result.steps) {
+    const viewSpec = step.panel.structuredContent?.["viewSpec"];
+    logger.log(`--- panel: ${step.stepId} ---`);
+    logger.log(JSON.stringify(viewSpec, null, 2));
+  }
+  if (!result.completed) {
+    logger.error(
+      `
+[capstone] FAILED at step "${result.error?.stepId}": ${result.error?.message}`
+    );
+    return 1;
+  }
+  const receipt = extractReceipt(result);
+  logger.log("\n=== Settlement Receipt ===");
+  logger.log(JSON.stringify(receipt, null, 2));
+  logger.log(`
+[capstone] completed all ${result.steps.length} steps.`);
+  return 0;
+}
+async function main(env = process.env) {
+  const baseUrl = env["TOON_DAEMON_URL"] ?? "http://127.0.0.1:8787";
+  const destination = env["TOON_SWAP_DEST"];
+  const amount = env["TOON_SWAP_AMOUNT"];
+  const millPubkey = env["TOON_MILL_PUBKEY"];
+  const chainRecipient = env["TOON_CHAIN_RECIPIENT"];
+  const pairRaw = env["TOON_SWAP_PAIR"];
+  if (!destination || !amount || !millPubkey || !chainRecipient || !pairRaw) {
+    console.error(
+      "[capstone] missing required env: TOON_SWAP_DEST, TOON_SWAP_AMOUNT, TOON_MILL_PUBKEY, TOON_CHAIN_RECIPIENT, TOON_SWAP_PAIR are all required for the live DeFi leg. See the module header for the full env contract."
+    );
+    return 2;
+  }
+  let pair;
+  try {
+    pair = JSON.parse(pairRaw);
+  } catch (e) {
+    console.error(`[capstone] TOON_SWAP_PAIR is not valid JSON: ${String(e)}`);
+    return 2;
+  }
+  const client = new ControlClient({ baseUrl });
+  const socialFiPubkey = env["TOON_SOCIALFI_PUBKEY"];
+  return runCapstoneDemo(client, {
+    ...socialFiPubkey ? { socialFi: { pubkey: socialFiPubkey } } : {},
+    deFi: { destination, amount, millPubkey, chainRecipient, pair }
+  });
+}
+var invokedDirectly = typeof process !== "undefined" && Array.isArray(process.argv) && /[/\\]journey[/\\]demo\.(ts|js|mjs)$/.test(process.argv[1] ?? "");
+if (invokedDirectly) {
+  main().then((code) => process.exit(code)).catch((err) => {
+    console.error("[capstone] fatal:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  });
+}
 export {
   ClientRunner,
   ControlApiError,