@secondlayer/cli 1.6.0 → 1.6.2

package/dist/cli.js

@@ -2229,8 +2229,8 @@ function migrateConfig(raw) {
   if (typeof old.dataDir === "string") {
     migrated.dataDir = old.dataDir;
   }
-  if (typeof old.defaultWebhookUrl === "string") {
-    migrated.defaultWebhookUrl = old.defaultWebhookUrl;
+  if (typeof old.defaultEndpointUrl === "string") {
+    migrated.defaultEndpointUrl = old.defaultEndpointUrl;
   }
   if (typeof old.nodeInstallPath === "string" || typeof old.nodeNetwork === "string") {
     migrated.node = {
@@ -2270,8 +2270,8 @@ async function loadConfig() {
     }
   }
   config = applyEnvOverrides(config);
-  if (!config.defaultWebhookUrl && config.network === "local") {
-    config.defaultWebhookUrl = LOCAL_WEBHOOK_URL;
+  if (!config.defaultEndpointUrl && config.network === "local") {
+    config.defaultEndpointUrl = LOCAL_ENDPOINT_URL;
   }
   return config;
 }
@@ -2301,12 +2301,15 @@ function applyEnvOverrides(config) {
       result.ports = { ...result.ports, indexer: port };
     }
   }
-  if (process.env.SL_WEBHOOK_PORT) {
-    const port = parseInt(process.env.SL_WEBHOOK_PORT, 10);
+  if (process.env.SL_RECEIVER_PORT) {
+    const port = parseInt(process.env.SL_RECEIVER_PORT, 10);
     if (!isNaN(port) && port > 0 && port <= 65535) {
-      result.ports = { ...result.ports, webhook: port };
+      result.ports = { ...result.ports, receiver: port };
     }
   }
+  if (process.env.STACKS_NODE_RPC_URL) {
+    result.nodeRpcUrl = process.env.STACKS_NODE_RPC_URL;
+  }
   if (process.env.DATABASE_URL) {
     result.database = { type: "external", url: process.env.DATABASE_URL };
   }
@@ -2395,13 +2398,13 @@ function isDefaultValue(config, key) {
   const defaultValue = getConfigValue(DEFAULT_CONFIG, key);
   return JSON.stringify(currentValue) === JSON.stringify(defaultValue);
 }
-var PortsSchema, NodeSchema, DatabaseSchema, NetworkSchema, API_URLS, ConfigSchema, CONFIG_DIR, CONFIG_PATH, LOCAL_WEBHOOK_URL = "http://localhost:3900/webhook", DEFAULT_CONFIG;
+var PortsSchema, NodeSchema, DatabaseSchema, NetworkSchema, API_URLS, ConfigSchema, CONFIG_DIR, CONFIG_PATH, LOCAL_ENDPOINT_URL = "http://localhost:3900/receiver", DEFAULT_CONFIG;
 var init_config = __esm(() => {
   init_fs();
   PortsSchema = z.object({
     api: z.number().int().min(1).max(65535).default(3800),
     indexer: z.number().int().min(1).max(65535).default(3700),
-    webhook: z.number().int().min(1).max(65535).default(3900)
+    receiver: z.number().int().min(1).max(65535).default(3900)
   });
   NodeSchema = z.object({
     installPath: z.string().min(1),
@@ -2421,8 +2424,9 @@ var init_config = __esm(() => {
     network: NetworkSchema.default("mainnet"),
     apiUrl: z.string().url().optional(),
     apiKey: z.string().optional(),
+    nodeRpcUrl: z.string().url().optional(),
     dataDir: z.string().default("~/.secondlayer/data"),
-    defaultWebhookUrl: z.string().url().optional(),
+    defaultEndpointUrl: z.string().url().optional(),
     node: NodeSchema.optional(),
     ports: PortsSchema.default({}),
     database: DatabaseSchema.default({})
@@ -2432,7 +2436,7 @@ var init_config = __esm(() => {
   DEFAULT_CONFIG = {
     network: "mainnet",
     dataDir: "~/.secondlayer/data",
-    ports: { api: 3800, indexer: 3700, webhook: 3900 },
+    ports: { api: 3800, indexer: 3700, receiver: 3900 },
     database: { type: "docker" }
   };
 });
@@ -12429,19 +12433,26 @@ function parseContractId(contractId) {
 
 // src/utils/api.ts
 class StacksApiClient {
-  static hasWarnedAboutApiKey = false;
   baseUrl;
   headers;
-  constructor(network = "mainnet", apiKey, apiUrl) {
-    this.baseUrl = apiUrl || API_URLS2[network];
-    this.headers = apiKey ? { "x-api-key": apiKey } : {};
-    if (!apiKey && !StacksApiClient.hasWarnedAboutApiKey) {
-      console.warn(`⚠️  No API key provided. You may be rate-limited.
-` + `   Set HIRO_API_KEY env var or use --api-key flag.
-` + "   Get a free key at: https://platform.hiro.so/");
-      StacksApiClient.hasWarnedAboutApiKey = true;
+  useProxy;
+  constructor(network = "mainnet", apiKey, apiUrl, slApiUrl) {
+    this.useProxy = !apiUrl && network !== "devnet";
+    if (this.useProxy) {
+      this.baseUrl = slApiUrl || "";
+      this.headers = {};
+    } else {
+      this.baseUrl = apiUrl || process.env.STACKS_NODE_RPC_URL || "http://localhost:3999";
+      this.headers = apiKey ? { "x-api-key": apiKey } : {};
     }
   }
+  async ensureProxy() {
+    if (!this.useProxy || this.baseUrl)
+      return;
+    const config = await loadConfig();
+    this.baseUrl = resolveApiUrl(config);
+    this.headers = authHeaders(config);
+  }
   async fetchWithErrorHandling(url, resourceType, resourceId) {
     try {
       const response2 = await gotWithRetry(url, {
@@ -12450,30 +12461,38 @@ class StacksApiClient {
       });
       return response2.body;
     } catch (error2) {
+      if (error2.response?.statusCode === 401) {
+        throw new Error("Authentication required. Run: secondlayer auth login");
+      }
       if (error2.response?.statusCode === 404) {
         throw new Error(`${resourceType} not found: ${resourceId}`);
       }
-      if (error2.response?.statusCode === 429) {
-        throw new Error("Rate limited. Please provide an API key in your config.");
-      }
       throw new Error(`Failed to fetch ${resourceType.toLowerCase()}: ${error2.message}`);
     }
   }
   async getContractInfo(contractId) {
+    await this.ensureProxy();
+    if (this.useProxy) {
+      const url2 = `${this.baseUrl}/api/node/contracts/${contractId}/abi`;
+      return this.fetchWithErrorHandling(url2, "Contract", contractId);
+    }
     const { address, contractName } = parseContractId(contractId);
     const url = `${this.baseUrl}/v2/contracts/interface/${address}/${contractName}`;
     return this.fetchWithErrorHandling(url, "Contract", contractId);
   }
   async getContractSource(contractId) {
     const { address, contractName } = parseContractId(contractId);
-    const url = `${this.baseUrl}/v2/contracts/source/${address}/${contractName}`;
+    const rpcUrl = process.env.STACKS_NODE_RPC_URL || this.baseUrl;
+    const url = `${rpcUrl}/v2/contracts/source/${address}/${contractName}`;
     const data = await this.fetchWithErrorHandling(url, "Contract source", contractId);
     return data.source;
   }
 }
-var gotWithRetry, API_URLS2;
+var gotWithRetry;
 var init_api = __esm(() => {
   init_source3();
+  init_config();
+  init_api_client();
   gotWithRetry = source_default2.extend({
     timeout: { request: 30000 },
     retry: {
@@ -12483,11 +12502,6 @@ var init_api = __esm(() => {
       calculateDelay: ({ attemptCount }) => attemptCount * 1000
     }
   });
-  API_URLS2 = {
-    mainnet: "https://api.hiro.so",
-    testnet: "https://api.testnet.hiro.so",
-    devnet: "http://localhost:3999"
-  };
 });
 
 // src/utils/network.ts
@@ -13189,9 +13203,9 @@ var init_api2 = __esm(() => {
   init_manager();
 });
 
-// src/services/webhook-server.ts
+// src/services/receiver-server.ts
 import { verifySignatureHeader } from "@secondlayer/shared/crypto";
-function startWebhookServer(options2 = {}) {
+function startReceiverServer(options2 = {}) {
   const port = options2.port ?? 3900;
   const responseCode = options2.responseCode ?? 200;
   server = Bun.serve({
@@ -13230,27 +13244,27 @@ function startWebhookServer(options2 = {}) {
         body,
         signatureValid
       };
-      if (options2.onWebhook) {
-        options2.onWebhook(event);
+      if (options2.onDelivery) {
+        options2.onDelivery(event);
       } else {
-        logWebhook(event);
+        logDelivery(event);
       }
       return new Response("OK", { status: responseCode });
     }
   });
   return port;
 }
-function stopWebhookServer() {
+function stopReceiverServer() {
   if (server) {
     server.stop();
     server = null;
   }
 }
-function logWebhook(event) {
+function logDelivery(event) {
   const time = event.timestamp.toISOString();
   console.log("");
   console.log(blue("━".repeat(60)));
-  console.log(green("⚡ Webhook received"));
+  console.log(green("⚡ Delivery received"));
   console.log(dim(`   ${time}`));
   console.log(dim(`   ${event.method} ${event.path}`));
   if (event.signatureValid === true) {
@@ -13272,7 +13286,7 @@ function logWebhook(event) {
   console.log(blue("━".repeat(60)));
 }
 var server = null;
-var init_webhook_server = __esm(() => {
+var init_receiver_server = __esm(() => {
   init_output();
 });
 
@@ -13300,7 +13314,7 @@ var init_services = __esm(() => {
   init_indexer();
   init_worker();
   init_api2();
-  init_webhook_server();
+  init_receiver_server();
   init_subgraph_processor();
 });
 
@@ -13344,7 +13358,7 @@ async function runBackground(options2) {
   const dataDir = getDataDir(config);
   const indexerPort = options2.stacksNode ? 3701 : parseInt(options2.indexerPort) || config.ports.indexer;
   const apiPort = parseInt(options2.apiPort) || config.ports.api;
-  const webhookPort = parseInt(options2.webhookPort) || config.ports.webhook;
+  const receiverPort = parseInt(options2.receiverPort) || config.ports.receiver;
   if (options2.stacksNode && config.node) {
     const validation = await validateNetworkConsistency(config);
     if (!validation.valid) {
@@ -13454,24 +13468,24 @@ async function runBackground(options2) {
       };
       console.log(green("  ✓ Subgraph processor"), dim("processing subgraphs"));
     }
-    if (options2.webhook) {
-      const webhookLogFile = getLogFile("webhook");
-      const webhookArgs = ["bun", "run", resolve6(packagesDir, "packages/cli/src/services/webhook-standalone.ts")];
-      const webhookEnv = { ...process.env, PORT: String(webhookPort) };
+    if (options2.receiver) {
+      const receiverLogFile = getLogFile("receiver");
+      const receiverArgs = ["bun", "run", resolve6(packagesDir, "packages/cli/src/services/receiver-standalone.ts")];
+      const receiverEnv = { ...process.env, PORT: String(receiverPort) };
       if (options2.secret)
-        webhookEnv.WEBHOOK_SECRET = options2.secret;
-      const webhookProc = Bun.spawn(webhookArgs, {
-        env: webhookEnv,
-        stdout: Bun.file(webhookLogFile),
-        stderr: Bun.file(webhookLogFile)
+        receiverEnv.SIGNING_SECRET = options2.secret;
+      const receiverProc = Bun.spawn(receiverArgs, {
+        env: receiverEnv,
+        stdout: Bun.file(receiverLogFile),
+        stderr: Bun.file(receiverLogFile)
       });
-      state.services.webhook = {
-        pid: webhookProc.pid,
-        port: webhookPort,
+      state.services.receiver = {
+        pid: receiverProc.pid,
+        port: receiverPort,
         startedAt: new Date().toISOString(),
-        logFile: webhookLogFile
+        logFile: receiverLogFile
       };
-      console.log(green("  ✓ Webhook server"), dim(`http://localhost:${webhookPort}`));
+      console.log(green("  ✓ Receiver server"), dim(`http://localhost:${receiverPort}`));
     }
     await Bun.sleep(500);
     for (const [name, service] of Object.entries(state.services)) {
@@ -13481,7 +13495,7 @@ async function runBackground(options2) {
     }
     await saveDevState(state);
     console.log("");
-    printUrls(indexerPort, apiPort, webhookPort, options2.webhook);
+    printUrls(indexerPort, apiPort, receiverPort, options2.receiver);
     console.log("");
     success("Dev environment started in background");
     console.log("");
@@ -13519,14 +13533,14 @@ async function runForeground(options2) {
   const dataDir = getDataDir(config);
   const indexerPort = options2.stacksNode ? 3701 : parseInt(options2.indexerPort) || config.ports.indexer;
   const apiPort = parseInt(options2.apiPort) || config.ports.api;
-  const webhookPort = parseInt(options2.webhookPort) || config.ports.webhook;
+  const receiverPort = parseInt(options2.receiverPort) || config.ports.receiver;
   let devPostgresStarted = false;
   const shutdown = async () => {
     console.log(`
 `);
     info("Shutting down services...");
-    if (options2.webhook) {
-      stopWebhookServer();
+    if (options2.receiver) {
+      stopReceiverServer();
     }
     await serviceManager.stopAll();
     if (devPostgresStarted) {
@@ -13573,9 +13587,9 @@ async function runForeground(options2) {
       console.log("");
     }
     process.env.DEV_MODE = "true";
-    if (options2.webhook) {
-      startWebhookServer({ port: webhookPort, secret: options2.secret });
-      console.log(green("  ✓ Webhook server"), dim(`http://localhost:${webhookPort}`));
+    if (options2.receiver) {
+      startReceiverServer({ port: receiverPort, secret: options2.secret });
+      console.log(green("  ✓ Receiver server"), dim(`http://localhost:${receiverPort}`));
     }
     await startApi({ port: apiPort, onLog: (line) => logService("api", line) });
     console.log(green("  ✓ API"), dim(`http://localhost:${apiPort}`));
@@ -13588,7 +13602,7 @@ async function runForeground(options2) {
     await startSubgraphProcessor({ onLog: (line) => logService("subgraphs", line) });
     console.log(green("  ✓ Subgraph processor"), dim("processing subgraphs"));
     console.log("");
-    printUrls(indexerPort, apiPort, webhookPort, options2.webhook);
+    printUrls(indexerPort, apiPort, receiverPort, options2.receiver);
     console.log("");
     info("Press Ctrl+C to stop all services");
     console.log("");
@@ -13596,8 +13610,8 @@ async function runForeground(options2) {
   } catch (err) {
     error(`Failed to start services: ${err}`);
     await serviceManager.stopAll();
-    if (options2.webhook) {
-      stopWebhookServer();
+    if (options2.receiver) {
+      stopReceiverServer();
     }
     process.exit(1);
   }
@@ -13628,10 +13642,10 @@ async function showLogs(options2) {
     await showStaticLogs(serviceEntries, lines, verbose);
   }
 }
-function formatWebhookSummary(jsonStr) {
+function formatDeliverySummary(jsonStr) {
   try {
     const data = JSON.parse(jsonStr);
-    if (data.type !== "webhook" || !data.body)
+    if (data.type !== "delivery" || !data.body)
       return null;
     const { body, method, path, timestamp } = data;
     const streamName = body.streamName ?? body.streamId?.slice(0, 8) ?? "unknown";
@@ -13661,8 +13675,8 @@ function formatLogLine2(service, line, verbose) {
       return `${prefix} ${dimTimestamp} ${dim(level + ":")} ${dim(message)}`;
     }
   }
-  if (service === "webhook" && !verbose) {
-    const summary = formatWebhookSummary(line);
+  if (service === "receiver" && !verbose) {
+    const summary = formatDeliverySummary(line);
     if (summary)
       return `${prefix} ${summary}`;
   }
@@ -13838,21 +13852,21 @@ async function restartDev() {
     };
     console.log(green("  ✓ Worker"), dim("processing jobs"));
   }
-  if (state.services.webhook) {
-    const webhookPort = config.ports.webhook;
-    const webhookLogFile = getLogFile("webhook");
-    const webhookProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/cli/src/services/webhook-standalone.ts")], {
-      env: { ...process.env, PORT: String(webhookPort) },
-      stdout: Bun.file(webhookLogFile),
-      stderr: Bun.file(webhookLogFile)
+  if (state.services.receiver) {
+    const receiverPort = config.ports.receiver;
+    const receiverLogFile = getLogFile("receiver");
+    const receiverProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/cli/src/services/receiver-standalone.ts")], {
+      env: { ...process.env, PORT: String(receiverPort) },
+      stdout: Bun.file(receiverLogFile),
+      stderr: Bun.file(receiverLogFile)
     });
-    newState.services.webhook = {
-      pid: webhookProc.pid,
-      port: webhookPort,
+    newState.services.receiver = {
+      pid: receiverProc.pid,
+      port: receiverPort,
       startedAt: new Date().toISOString(),
-      logFile: webhookLogFile
+      logFile: receiverLogFile
     };
-    console.log(green("  ✓ Webhook server"), dim(`http://localhost:${webhookPort}`));
+    console.log(green("  ✓ Receiver server"), dim(`http://localhost:${receiverPort}`));
   }
   if (state.services.subgraphs) {
     const subgraphsLogFile = getLogFile("subgraphs");
@@ -13928,7 +13942,7 @@ function printBanner2() {
   console.log(dim("  Starting services..."));
   console.log("");
 }
-function printUrls(indexerPort, apiPort, webhookPort, webhookEnabled) {
+function printUrls(indexerPort, apiPort, receiverPort, receiverEnabled) {
   console.log(dim("  ─────────────────────────────────────────"));
   console.log("");
   console.log("  " + blue("API:"));
@@ -13939,9 +13953,9 @@ function printUrls(indexerPort, apiPort, webhookPort, webhookEnabled) {
   console.log(`    Health check:   curl http://localhost:${indexerPort}/health`);
   console.log(`    Send block:     curl -X POST http://localhost:${indexerPort}/new_block -d @block.json`);
   console.log("");
-  if (webhookEnabled) {
-    console.log("  " + blue("Test Webhook:"));
-    console.log(`    Receives webhooks at http://localhost:${webhookPort}/`);
+  if (receiverEnabled) {
+    console.log("  " + blue("Test Receiver:"));
+    console.log(`    Receives deliveries at http://localhost:${receiverPort}/`);
     console.log(`    Use this URL when creating streams for testing`);
     console.log("");
   }
@@ -14018,7 +14032,7 @@ var init_dev_impl = __esm(() => {
     indexer: cyan,
     worker: yellow,
     subgraphs: magenta,
-    webhook: green
+    receiver: green
   };
 });
 
@@ -32538,7 +32552,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "1.6.0",
+  version: "1.6.2",
   description: "CLI for streams, subgraphs, and real-time blockchain indexing on Stacks",
   type: "module",
   bin: {
@@ -32930,7 +32944,7 @@ async function printConfigTree(cfg) {
     console.log(blue("ports:"));
     printValue("  api", cfg.ports.api, cfg.ports.api === defaults.ports.api, 2);
     printValue("  indexer", cfg.ports.indexer, cfg.ports.indexer === defaults.ports.indexer, 2);
-    printValue("  webhook", cfg.ports.webhook, cfg.ports.webhook === defaults.ports.webhook, 2);
+    printValue("  receiver", cfg.ports.receiver, cfg.ports.receiver === defaults.ports.receiver, 2);
     console.log("");
     console.log(blue("database:"));
     printValue("  type", cfg.database.type, cfg.database.type === "docker", 2);
@@ -32976,13 +32990,13 @@ import { select as select2, input, confirm } from "@inquirer/prompts";
 init_config();
 var STREAMS_DIR = "streams";
 function registerSetupCommand(program2) {
-  program2.command("setup").description("Set up a streams project and configure settings").option("--detect-only", "Only detect existing Stacks nodes, don't initialize").option("-y, --yes", "Use defaults without prompts").option("--data-dir <path>", "Data directory path").option("--node-path <path>", "Path to Stacks node").option("--network <network>", "Network (local, testnet, or mainnet)").option("--webhook-url <url>", "Default webhook URL for new streams").action(async (options) => {
+  program2.command("setup").description("Set up a streams project and configure settings").option("--detect-only", "Only detect existing Stacks nodes, don't initialize").option("-y, --yes", "Use defaults without prompts").option("--data-dir <path>", "Data directory path").option("--node-path <path>", "Path to Stacks node").option("--network <network>", "Network (local, testnet, or mainnet)").option("--endpoint-url <url>", "Default endpoint URL for new streams").action(async (options) => {
     try {
       if (options.detectOnly) {
         await runDetection();
         return;
       }
-      const hasFlags = options.yes || options.dataDir || options.nodePath || options.network || options.webhookUrl;
+      const hasFlags = options.yes || options.dataDir || options.nodePath || options.network || options.endpointUrl;
       if (hasFlags) {
         await runNonInteractive(options);
         return;
@@ -33011,7 +33025,7 @@ async function runNonInteractive(options) {
     return;
   }
   config.dataDir = options.dataDir || config.dataDir || "~/.secondlayer/data";
-  config.defaultWebhookUrl = options.webhookUrl || config.defaultWebhookUrl;
+  config.defaultEndpointUrl = options.endpointUrl || config.defaultEndpointUrl;
   if (options.nodePath) {
     config.node = {
       installPath: options.nodePath,
@@ -33055,8 +33069,8 @@ async function runWizard() {
   if (nodeConfig) {
     config.node = nodeConfig;
   }
-  const webhookUrl = await promptWebhookUrl(config);
-  config.defaultWebhookUrl = webhookUrl;
+  const endpointUrl = await promptEndpointUrl(config);
+  config.defaultEndpointUrl = endpointUrl;
   await saveConfig(config);
   await Bun.$`mkdir -p ${STREAMS_DIR}`.quiet();
   await Bun.write(`${STREAMS_DIR}/.gitkeep`, "");
@@ -33183,10 +33197,10 @@ async function promptNetwork() {
   });
   return network;
 }
-async function promptWebhookUrl(config) {
-  const internalUrl = "http://localhost:3900/webhook";
+async function promptEndpointUrl(config) {
+  const internalUrl = "http://localhost:3900/receiver";
   const choice = await select2({
-    message: "Default webhook URL for new streams?",
+    message: "Default endpoint URL for new streams?",
     choices: [
       { name: `Internal test server (${internalUrl})`, value: "internal" },
       { name: "Custom URL...", value: "custom" }
@@ -33196,8 +33210,8 @@ async function promptWebhookUrl(config) {
     return internalUrl;
   }
   const customUrl = await input({
-    message: "Enter webhook URL:",
-    default: config.defaultWebhookUrl !== internalUrl ? config.defaultWebhookUrl : undefined,
+    message: "Enter endpoint URL:",
+    default: config.defaultEndpointUrl !== internalUrl ? config.defaultEndpointUrl : undefined,
     validate: (value) => {
       if (!value.trim())
         return "URL cannot be empty";
@@ -33295,8 +33309,8 @@ function printSummary(config) {
   console.log();
   console.log("  Settings:");
   console.log(`    Data directory: ${config.dataDir}`);
-  if (config.defaultWebhookUrl) {
-    console.log(`    Webhook URL:    ${config.defaultWebhookUrl}`);
+  if (config.defaultEndpointUrl) {
+    console.log(`    Endpoint URL:   ${config.defaultEndpointUrl}`);
   }
   if (config.node) {
     console.log(`    Node path:      ${config.node.installPath}`);
@@ -33345,10 +33359,10 @@ function printNodeInfo(node) {
 import { join as join3 } from "node:path";
 
 // src/templates/stream.ts
-function generateStreamTemplate(name, webhookUrl) {
+function generateStreamTemplate(name, endpointUrl) {
   return {
     name,
-    webhookUrl: webhookUrl || "https://example.com/webhook",
+    endpointUrl: endpointUrl || "https://example.com/endpoint",
     filters: [
       {
         type: "contract_call",
@@ -33384,12 +33398,12 @@ function registerNewCommand(program2) {
       if (dir) {
         await ensureDir(dir);
       }
-      const template = generateStreamTemplate(name, config.defaultWebhookUrl);
+      const template = generateStreamTemplate(name, config.defaultEndpointUrl);
       await writeTextFile(outputPath, JSON.stringify(template, null, 2) + `
 `);
       success(`Created ${outputPath}`);
-      if (!config.defaultWebhookUrl) {
-        warn("Edit the webhookUrl before registering — it must be a reachable HTTPS endpoint");
+      if (!config.defaultEndpointUrl) {
+        warn("Edit the endpointUrl before registering — it must be a reachable HTTPS endpoint");
       }
       console.log(`
 Edit the file to configure your stream, then run:`);
@@ -33452,7 +33466,7 @@ function registerGetCommand(program2) {
         ["ID", stream.id],
         ["Name", stream.name],
         ["Status", statusColor(stream.status)],
-        ["Webhook URL", stream.webhookUrl],
+        ["Endpoint URL", stream.endpointUrl],
         ["Total Deliveries", stream.totalDeliveries.toString()],
         ["Failed Deliveries", stream.failedDeliveries.toString()],
         ["Last Triggered", stream.lastTriggeredAt || dim("never")],
@@ -33520,10 +33534,10 @@ function registerRegisterCommand(program2) {
       console.log(formatKeyValue([
         ["ID", result.stream.id],
         ["Name", result.stream.name],
-        ["Webhook Secret", result.webhookSecret]
+        ["Signing Secret", result.signingSecret]
       ]));
       console.log(dim(`
-Save the webhook secret - it won't be shown again!`));
+Save the signing secret - it won't be shown again!`));
     } catch (err) {
       handleApiError(err, "register stream");
     }
@@ -34019,12 +34033,12 @@ init_api_client();
 init_output();
 import { confirm as confirm3 } from "@inquirer/prompts";
 function registerRotateSecretCommand(program2) {
-  program2.command("rotate-secret <id>").description("Generate a new webhook secret for a stream").option("-y, --yes", "Skip confirmation prompt").action(async (id, options) => {
+  program2.command("rotate-secret <id>").description("Generate a new signing secret for a stream").option("-y, --yes", "Skip confirmation prompt").action(async (id, options) => {
     try {
       const stream = await getStream(id);
       if (!options.yes) {
         const confirmed = await confirm3({
-          message: `Rotate webhook secret for "${stream.name}"? The current secret will be invalidated.`,
+          message: `Rotate signing secret for "${stream.name}"? The current secret will be invalidated.`,
           default: false
         });
         if (!confirmed) {
@@ -34033,13 +34047,13 @@ function registerRotateSecretCommand(program2) {
         }
       }
       const result = await rotateSecret(stream.id);
-      success(`Rotated webhook secret for: ${stream.name}`);
+      success(`Rotated signing secret for: ${stream.name}`);
       console.log(formatKeyValue([
         ["Stream", stream.name],
-        ["Webhook Secret", result.secret]
+        ["Signing Secret", result.secret]
       ]));
       console.log(dim(`
-Save the webhook secret - it won't be shown again!`));
+Save the signing secret - it won't be shown again!`));
     } catch (err) {
       handleApiError(err, "rotate secret");
     }
@@ -34722,15 +34736,15 @@ async function resyncDatabase(skipConfirm, backfill) {
     process.exit(1);
   }
 }
-// src/commands/webhook.ts
+// src/commands/receiver.ts
 init_output();
 init_config();
 import { join as join5 } from "node:path";
-function registerWebhookCommand(program2) {
-  const webhook = program2.command("webhook").description("Webhook development tools").hook("preAction", async () => {
+function registerReceiverCommand(program2) {
+  const receiver = program2.command("receiver").description("Receiver development tools").hook("preAction", async () => {
     await requireLocalNetwork();
   });
-  webhook.command("init <directory>").description("Scaffold a webhook handler with types and signature verification").option("-n, --name <name>", "Stream name", "my-stream").option("--network <network>", "Network (mainnet/testnet)", "mainnet").option("-p, --port <port>", "Server port", "4000").action(async (directory, options) => {
+  receiver.command("init <directory>").description("Scaffold a receiver handler with types and signature verification").option("-n, --name <name>", "Stream name", "my-stream").option("--network <network>", "Network (mainnet/testnet)", "mainnet").option("-p, --port <port>", "Server port", "4000").action(async (directory, options) => {
     try {
       const config = await loadConfig();
       const port = parseInt(options.port);
@@ -34744,13 +34758,13 @@ function registerWebhookCommand(program2) {
       await Bun.$`mkdir -p ${dir}`.quiet();
       await generateServerFile(dir, port);
       await generateTypesFile(dir);
-      await generateStreamJson(dir, options.name, network, port, config.defaultWebhookUrl);
+      await generateStreamJson(dir, options.name, network, port, config.defaultEndpointUrl);
       await generateEnvFile(dir);
       await generatePackageJson(dir, options.name);
-      success(`Created webhook handler in ${directory}/`);
+      success(`Created receiver handler in ${directory}/`);
       console.log("");
       console.log("  Files created:");
-      console.log(`    ${dim("server.ts")}      Webhook server with HMAC verification`);
+      console.log(`    ${dim("server.ts")}      Receiver server with HMAC verification`);
       console.log(`    ${dim("types.ts")}       Payload type definitions`);
       console.log(`    ${dim("stream.json")}    Stream configuration`);
       console.log(`    ${dim(".env")}           Environment variables`);
@@ -34765,26 +34779,26 @@ function registerWebhookCommand(program2) {
       console.log(`    sl streams register ${directory}/stream.json`);
       console.log("");
     } catch (err) {
-      error(`Failed to scaffold webhook: ${err}`);
+      error(`Failed to scaffold receiver: ${err}`);
       process.exit(1);
     }
   });
 }
 async function generateServerFile(dir, port) {
-  const content = `import type { WebhookPayload } from "./types.ts";
+  const content = `import type { DeliveryPayload } from "./types.ts";
 
-const WEBHOOK_SECRET = process.env.STREAMS_WEBHOOK_SECRET;
+const SIGNING_SECRET = process.env.STREAMS_SIGNING_SECRET;
 
 /**
  * Verify HMAC signature from Stacks Streams
  */
 async function verifySignature(body: string, signature: string | null): Promise<boolean> {
-  if (!WEBHOOK_SECRET || !signature) return false;
+  if (!SIGNING_SECRET || !signature) return false;
 
   const encoder = new TextEncoder();
   const key = await crypto.subtle.importKey(
     "raw",
-    encoder.encode(WEBHOOK_SECRET),
+    encoder.encode(SIGNING_SECRET),
     { name: "HMAC", hash: "SHA-256" },
     false,
     ["sign"]
@@ -34797,9 +34811,9 @@ async function verifySignature(body: string, signature: string | null): Promise<
 }
 
 /**
- * Handle incoming webhook payload
+ * Handle incoming delivery payload
  */
-async function handlePayload(payload: WebhookPayload): Promise<void> {
+async function handlePayload(payload: DeliveryPayload): Promise<void> {
   console.log(\`Block \${payload.block.height}: \${payload.matches.events.length} events\`);
 
   for (const event of payload.matches.events) {
@@ -34838,13 +34852,13 @@ Bun.serve({
       return new Response("ok");
     }
 
-    // Webhook endpoint
+    // Receiver endpoint
     if (req.method === "POST" && url.pathname === "/payload") {
       const body = await req.text();
       const signature = req.headers.get("x-streams-signature");
 
       // Verify signature
-      if (WEBHOOK_SECRET) {
+      if (SIGNING_SECRET) {
         const valid = await verifySignature(body, signature);
         if (!valid) {
           console.error("Invalid signature");
@@ -34853,7 +34867,7 @@ Bun.serve({
       }
 
       try {
-        const payload: WebhookPayload = JSON.parse(body);
+        const payload: DeliveryPayload = JSON.parse(body);
         await handlePayload(payload);
         return new Response("ok");
       } catch (err) {
@@ -34866,18 +34880,18 @@ Bun.serve({
   },
 });
 
-console.log(\`Webhook server listening on http://localhost:${port}/payload\`);
+console.log(\`Receiver server listening on http://localhost:${port}/payload\`);
 `;
   await Bun.write(join5(dir, "server.ts"), content);
 }
 async function generateTypesFile(dir) {
   const content = `/**
- * Stacks Streams Webhook Payload Types
+ * Stacks Streams Delivery Payload Types
  *
  * These types match the payload structure sent by Stacks Streams.
  */
 
-export interface WebhookPayload {
+export interface DeliveryPayload {
   streamId: string;
   streamName: string;
   network: "mainnet" | "testnet";
@@ -34999,11 +35013,11 @@ export function isPrintEvent(event: EventMatch): event is PrintEvent {
 `;
   await Bun.write(join5(dir, "types.ts"), content);
 }
-async function generateStreamJson(dir, name, network, port, _defaultWebhookUrl) {
+async function generateStreamJson(dir, name, network, port, _defaultEndpointUrl) {
   const content = {
     name,
     network,
-    webhookUrl: `http://localhost:${port}/payload`,
+    endpointUrl: `http://localhost:${port}/payload`,
     filters: [
       {
         type: "stx_transfer",
@@ -35023,9 +35037,9 @@ async function generateStreamJson(dir, name, network, port, _defaultWebhookUrl)
 `);
 }
 async function generateEnvFile(dir) {
-  const content = `# Stacks Streams Webhook Secret
+  const content = `# Stacks Streams Signing Secret
 # Get this from: sl streams register stream.json
-STREAMS_WEBHOOK_SECRET=
+STREAMS_SIGNING_SECRET=
 
 # Add your database connection, etc.
 # DATABASE_URL=postgres://...
@@ -35034,7 +35048,7 @@ STREAMS_WEBHOOK_SECRET=
 }
 async function generatePackageJson(dir, name) {
   const content = {
-    name: `${name}-webhook`,
+    name: `${name}-receiver`,
     version: "0.1.0",
     type: "module",
     scripts: {
@@ -35941,7 +35955,7 @@ async function checkHealth() {
   const portsToCheck = [
     { port: config.ports.api, name: "API" },
     { port: config.ports.indexer, name: "Indexer" },
-    { port: config.ports.webhook, name: "Webhook" },
+    { port: config.ports.receiver, name: "Receiver" },
     { port: 20443, name: "Node RPC" }
   ];
   for (const { port, name } of portsToCheck) {
@@ -36413,14 +36427,14 @@ init_config();
 init_dev_state();
 init_node_manager();
 init_output();
-var DEV_SERVICES = ["api", "indexer", "worker", "webhook", "subgraphs"];
+var DEV_SERVICES = ["api", "indexer", "worker", "receiver", "subgraphs"];
 function registerLocalCommand(program2) {
   const local = program2.command("local").description("Manage local development environment and Stacks node").hook("preAction", async (_thisCommand, actionCommand) => {
     if (actionCommand.name() === "help")
       return;
     await requireLocalNetwork();
   });
-  local.command("start").description("Start all local dev services (API, indexer, worker, webhook)").option("--indexer-port <port>", "Indexer port", "3700").option("--api-port <port>", "API port", "3800").option("--webhook-port <port>", "Test webhook server port", "3900").option("--no-webhook", "Skip test webhook server").option("--no-worker", "Skip worker service").option("--secret <secret>", "Webhook secret for signature verification").option("--stacks-node", "Use port 3701 for indexer (avoids conflict with stacks-blockchain-api)").option("-f, --foreground", "Run in foreground (blocking)").action(async (options2) => {
+  local.command("start").description("Start all local dev services (API, indexer, worker, receiver)").option("--indexer-port <port>", "Indexer port", "3700").option("--api-port <port>", "API port", "3800").option("--receiver-port <port>", "Test receiver server port", "3900").option("--no-receiver", "Skip test receiver server").option("--no-worker", "Skip worker service").option("--secret <secret>", "Signing secret for signature verification").option("--stacks-node", "Use port 3701 for indexer (avoids conflict with stacks-blockchain-api)").option("-f, --foreground", "Run in foreground (blocking)").action(async (options2) => {
     const { runBackground: runBackground2, runForeground: runForeground2, isDevAlreadyRunning: isDevAlreadyRunning2 } = await Promise.resolve().then(() => (init_dev_impl(), exports_dev_impl));
     if (await isDevAlreadyRunning2()) {
       return;
@@ -36442,7 +36456,7 @@ function registerLocalCommand(program2) {
   local.command("status").description("Show local environment status").action(async () => {
     await showLocalStatus();
   });
-  local.command("logs").description("View local service logs (dev + node)").option("-s, --service <name>", "Filter by service (api, indexer, worker, webhook, subgraphs, node)").option("-f, --follow", "Follow log output").option("-n, --lines <n>", "Number of lines to show", "50").option("-q, --quiet", "Filter out common noise").option("-v, --verbose", "Show full payloads").action(async (options2) => {
+  local.command("logs").description("View local service logs (dev + node)").option("-s, --service <name>", "Filter by service (api, indexer, worker, receiver, subgraphs, node)").option("-f, --follow", "Follow log output").option("-n, --lines <n>", "Number of lines to show", "50").option("-q, --quiet", "Filter out common noise").option("-v, --verbose", "Show full payloads").action(async (options2) => {
     await showLocalLogs(options2);
   });
   const node = local.command("node").description("Manage local Stacks node");
@@ -36519,7 +36533,7 @@ var serviceColors2 = {
   indexer: cyan,
   worker: yellow,
   subgraphs: magenta,
-  webhook: green,
+  receiver: green,
   node: red
 };
 async function showLocalLogs(options2) {
@@ -36671,17 +36685,17 @@ function formatLogLine3(service, line, verbose) {
       return `${prefix} ${dimTimestamp} ${dim(level + ":")} ${dim(message)}`;
     }
   }
-  if (service === "webhook" && !verbose) {
-    const summary = formatWebhookSummary2(line);
+  if (service === "receiver" && !verbose) {
+    const summary = formatDeliverySummary2(line);
     if (summary)
       return `${prefix} ${summary}`;
   }
   return `${prefix} ${line}`;
 }
-function formatWebhookSummary2(jsonStr) {
+function formatDeliverySummary2(jsonStr) {
   try {
     const data = JSON.parse(jsonStr);
-    if (data.type !== "webhook" || !data.body)
+    if (data.type !== "delivery" || !data.body)
       return null;
     const { body, method, path, timestamp } = data;
     const streamName = body.streamName ?? body.streamId?.slice(0, 8) ?? "unknown";
@@ -36765,8 +36779,8 @@ registerSetupCommand(program);
 registerConfigCommand(program);
 registerAuthCommand(program);
 registerWhoamiCommand(program);
-registerWebhookCommand(program);
+registerReceiverCommand(program);
 program.parse();
 
-//# debugId=2320C06E5C8D182A64756E2164756E21
+//# debugId=2EB552BA8CA7A84564756E2164756E21
 //# sourceMappingURL=cli.js.map