@tuwaio/quasar-sdk 0.1.8 → 0.1.10

package/README.md

@@ -22,6 +22,7 @@ It operates strictly on the server (Node.js, Next.js Server Actions, or Edge fun
 ## ✨ Key Features
 
 - **☁️ Cloud Sync**: Automatically persist pending and terminal transaction states to the Quasar Database for cross-device history.
+- **⚡ Native Webhook Local Dev Relay**: Stream production webhooks directly to your local machine via CLI with zero tunnels (no ngrok/cloudflared required).
 - **🔐 Headless SIWX (CAIP-122) Auth Ready**: Seamlessly pairs with `@tuwaio/sdk/siwx/server` for strict cryptographic verification of user sessions before allowing database writes.
 - **⚡ Edge Ready**: Uses `ofetch` and lightweight cryptography to run seamlessly in Cloudflare Workers and Vercel Edge.
 - **📦 InMemory Sync**: Perfectly pairs with `@tuwaio/sdk/pulsar` (`createTxInMemoryStore`) to fetch history and hydrate local React states.
@@ -38,6 +39,87 @@ _Note: `ofetch` and `@tuwaio/pulsar-core` are required peer dependencies. The `@
 
 ---
 
+## ⚡ Quasar Webhook Local Dev Relay (Native CLI)
+
+Testing Web3 webhooks locally against live cloud indexers usually requires spinning up temporary third-party tunnels (`ngrok`, `cloudflared`), pasting ephemeral URLs into dashboard forms, and restarting your workflow when tunnels expire.
+
+The **Quasar SDK CLI** provides a zero-tunnel local development relay. When you configure a `localhost` webhook endpoint in the Quasar Dashboard, Quasar Cloud streams incoming events to your local machine via real-time Server-Sent Events (SSE).
+
+### 1. Zero-Config Local Development
+
+Add your webhook signing secret from the Quasar Dashboard to `.env.local` or `.env`:
+
+```env
+# Signing secret copied from the Quasar Dashboard webhook endpoint
+QUASAR_WEBHOOK_SECRET=whsec_...
+
+# Optional Quasar API base URL (defaults to https://api.tuwa.io)
+NEXT_PUBLIC_QUASAR_BASE_URL=https://api.tuwa.io
+```
+
+Run the relay listener in your terminal:
+
+```bash
+npx @tuwaio/quasar-sdk listen
+```
+
+The CLI automatically reads `QUASAR_WEBHOOK_SECRET` and starts forwarding webhook payloads to the default Cosmos Playground endpoint (`http://localhost:3000/api/webhooks/quasar`).
+
+### 2. Custom Forwarding & CLI Options
+
+```bash
+# Forward to a custom port or path
+npx @tuwaio/quasar-sdk listen --forward-to http://localhost:8080/api/webhooks
+
+# Provide secret explicitly via flags
+npx @tuwaio/quasar-sdk listen --secret whsec_... --forward-to http://localhost:3000/api/webhooks/quasar
+
+# Specify custom .env file
+npx @tuwaio/quasar-sdk listen --env-file .env.development
+```
+
+| Flag           | Shorthand | Description                                   | Default                                     |
+| :------------- | :-------- | :-------------------------------------------- | :------------------------------------------ |
+| `--secret`     | `-s`      | Webhook endpoint signing secret (`whsec_...`) | `QUASAR_WEBHOOK_SECRET`                     |
+| `--forward-to` | `-f`      | Local destination endpoint                    | `http://localhost:3000/api/webhooks/quasar` |
+| `--api-url`    | `-a`      | Quasar Cloud API base URL                     | `https://api.tuwa.io`                       |
+| `--env-file`   | `-e`      | Custom path to `.env` file                    | Auto-detected (`.env.local`, `.env`)        |
+| `--help`       | `-h`      | Display help instructions                     | —                                           |
+| `--version`    | `-v`      | Display CLI version                           | —                                           |
+
+### 3. Local Webhook Route Handler (Next.js Example)
+
+```typescript
+// app/api/webhooks/quasar/route.ts
+import { NextResponse } from 'next/server';
+import crypto from 'node:crypto';
+
+export async function POST(req: Request) {
+  const secret = process.env.QUASAR_WEBHOOK_SECRET;
+  if (!secret) {
+    return NextResponse.json({ error: 'Server misconfigured' }, { status: 500 });
+  }
+
+  const rawBody = await req.text();
+  const signature = req.headers.get('x-quasar-signature');
+  const event = req.headers.get('x-quasar-event');
+
+  // Verify HMAC-SHA256 signature
+  const expectedSignature = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
+
+  if (signature !== expectedSignature) {
+    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
+  }
+
+  const payload = JSON.parse(rawBody);
+  console.log(`[Webhook Received] ${event}:`, payload);
+
+  return NextResponse.json({ received: true });
+}
+```
+
+---
+
 ## 🚀 Quick Start (Node.js / Edge)
 
 This is a basic example of how to interact with the Quasar Cloud directly from your secure backend environments (like Next.js API Routes, Server Actions, or NestJS).

package/dist/cli.cjs

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  CLI_VERSION: () => CLI_VERSION,
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  DEFAULT_FORWARD_URL: () => DEFAULT_FORWARD_URL,
+  handleSseMessage: () => handleSseMessage,
+  loadEnv: () => loadEnv,
+  main: () => main,
+  parseArgs: () => parseArgs,
+  parseEnvFile: () => parseEnvFile
+});
+module.exports = __toCommonJS(cli_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+
+// package.json
+var package_default = {
+  name: "@tuwaio/quasar-sdk",
+  version: "0.1.10",
+  private: false,
+  author: "Oleksandr Tkach",
+  license: "Apache-2.0",
+  description: "Layer 5 (L5) of the TUWA Ecosystem. The Quasar Cloud SDK providing server-side Node.js & Edge utilities for transaction indexing, billing, and backend API integration.",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    }
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist",
+    "socket.json"
+  ],
+  bin: {
+    "@tuwaio/quasar-sdk": "./dist/cli.cjs",
+    "quasar-sdk": "./dist/cli.cjs"
+  },
+  scripts: {
+    start: "tsup src/index.ts --watch",
+    build: "tsup",
+    test: "vitest run"
+  },
+  keywords: [
+    "tuwa",
+    "web3",
+    "evm",
+    "ethereum",
+    "solana",
+    "wagmi",
+    "viem",
+    "@solana/kit",
+    "wallet-standard",
+    "wallet",
+    "wallet-connect",
+    "wallets",
+    "transaction",
+    "tracking",
+    "transaction-tracking",
+    "react",
+    "ui",
+    "ui-kit",
+    "design-system",
+    "hooks",
+    "utils",
+    "components",
+    "tailwind",
+    "tailwindcss",
+    "typescript",
+    "core",
+    "headless",
+    "zustand",
+    "immer",
+    "i18n",
+    "modal",
+    "toast",
+    "quasar",
+    "cloud",
+    "sdk",
+    "next-auth",
+    "cosmos",
+    "playground",
+    "cli"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/TuwaIO/sdk.git",
+    directory: "packages/quasar-sdk"
+  },
+  homepage: "https://github.com/TuwaIO/sdk",
+  bugs: {
+    url: "https://github.com/TuwaIO/sdk/issues"
+  },
+  contributors: [
+    {
+      name: "Oleksandr Tkach",
+      url: "https://github.com/Argeare5"
+    }
+  ],
+  peerDependencies: {
+    "@tuwaio/pulsar-core": ">=0.7",
+    ofetch: "^1.5.1",
+    "@tuwaio/siwx-react": ">=0.3",
+    "@tuwaio/siwx-core": ">=0.3",
+    "@tuwaio/siwx-server": ">=0.3"
+  },
+  peerDependenciesMeta: {
+    "@tuwaio/pulsar-core": {
+      optional: false
+    },
+    ofetch: {
+      optional: false
+    },
+    "@tuwaio/siwx-core": {
+      optional: true
+    },
+    "@tuwaio/siwx-server": {
+      optional: true
+    },
+    "@tuwaio/siwx-react": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@tuwaio/pulsar-core": "^0.7.0",
+    ofetch: "^1.5.1",
+    tsup: "^8.5.1",
+    typescript: "6.0.3",
+    "@tuwaio/siwx-react": "^0.3.0",
+    "@tuwaio/siwx-core": "^0.3.0",
+    "@tuwaio/siwx-server": "^0.3.0"
+  }
+};
+
+// src/cli.ts
+var DEFAULT_FORWARD_URL = "http://localhost:3000/api/webhooks/quasar";
+var DEFAULT_API_URL = "https://api.tuwa.io";
+var CLI_VERSION = package_default.version || "0.0.0";
+function parseEnvFile(content) {
+  const env = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const equalsIdx = trimmed.indexOf("=");
+    if (equalsIdx <= 0) continue;
+    const key = trimmed.slice(0, equalsIdx).trim();
+    let val = trimmed.slice(equalsIdx + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    env[key] = val;
+  }
+  return env;
+}
+function loadEnv(customPath) {
+  const cwd = process.cwd();
+  if (customPath) {
+    const fullPath = path.isAbsolute(customPath) ? customPath : path.join(cwd, customPath);
+    if (fs.existsSync(fullPath)) {
+      return parseEnvFile(fs.readFileSync(fullPath, "utf8"));
+    }
+    console.warn(`\x1B[33m[warn]\x1B[0m Specified env file not found: ${customPath}`);
+    return {};
+  }
+  const candidates = [".env.local", ".env.development", ".env"];
+  for (const candidate of candidates) {
+    const filePath = path.join(cwd, candidate);
+    if (fs.existsSync(filePath)) {
+      return parseEnvFile(fs.readFileSync(filePath, "utf8"));
+    }
+  }
+  return {};
+}
+function parseArgs(args) {
+  const options = {};
+  const cleanArgs = [...args];
+  if (cleanArgs.length > 0 && !cleanArgs[0].startsWith("-")) {
+    options.command = cleanArgs.shift();
+  }
+  for (let i = 0; i < cleanArgs.length; i++) {
+    const arg = cleanArgs[i];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      options.version = true;
+    } else if (arg === "--secret" || arg === "-s") {
+      options.secret = cleanArgs[++i];
+    } else if (arg === "--forward-to" || arg === "-f") {
+      options.forwardTo = cleanArgs[++i];
+    } else if (arg === "--api-url" || arg === "-a") {
+      options.apiUrl = cleanArgs[++i];
+    } else if (arg === "--env-file" || arg === "-e") {
+      options.envFile = cleanArgs[++i];
+    }
+  }
+  return options;
+}
+function printHelp() {
+  console.log(`
+\x1B[1m\x1B[36m\u26A1 Quasar Webhook Local Dev Relay\x1B[0m
+Stream production Quasar Cloud webhooks directly to your local dev machine.
+Zero tunnels, zero third-party proxies, zero friction.
+
+\x1B[1mUSAGE\x1B[0m
+  $ npx @tuwaio/quasar-sdk listen [options]
+
+\x1B[1mCOMMANDS\x1B[0m
+  listen                     Connect to Quasar Cloud SSE and forward events locally
+
+\x1B[1mOPTIONS\x1B[0m
+  -s, --secret <secret>      Webhook signing secret (whsec_...) [or QUASAR_WEBHOOK_SECRET]
+  -f, --forward-to <url>     Local endpoint to forward to (default: ${DEFAULT_FORWARD_URL})
+  -a, --api-url <url>        Quasar Cloud API base URL (default: ${DEFAULT_API_URL})
+  -e, --env-file <path>      Custom path to .env file
+  -v, --version              Show version number
+  -h, --help                 Show help details
+
+\x1B[1mZERO-CONFIG SETUP\x1B[0m
+  Add to your local .env or .env.local:
+    QUASAR_WEBHOOK_SECRET=whsec_...
+    NEXT_PUBLIC_QUASAR_BASE_URL=https://api.tuwa.io  # (optional)
+
+  Then simply run:
+    $ npx @tuwaio/quasar-sdk listen
+`);
+}
+async function runListen(options) {
+  const { secret, forwardTo, apiUrl } = options;
+  const cleanApiUrl = apiUrl.replace(/\/+$/, "");
+  const listenUrl = `${cleanApiUrl}/v1/engine/webhooks/listen?secret=${encodeURIComponent(secret)}`;
+  console.log(`
+\x1B[36m\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\x1B[0m
+\x1B[36m\u2502\x1B[0m  \x1B[1m\x1B[36m\u26A1 Quasar Webhook Local Dev Relay\x1B[0m                           \x1B[36m\u2502\x1B[0m
+\x1B[36m\u2502\x1B[0m  Forwarding to: \x1B[32m${forwardTo.padEnd(44)}\x1B[0m\x1B[36m\u2502\x1B[0m
+\x1B[36m\u2502\x1B[0m  Quasar Cloud:  \x1B[34m${cleanApiUrl.padEnd(44)}\x1B[0m\x1B[36m\u2502\x1B[0m
+\x1B[36m\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\x1B[0m
+`);
+  let reconnectDelay = 1e3;
+  let isShuttingDown = false;
+  let activeAbortController = null;
+  const cleanup = () => {
+    isShuttingDown = true;
+    if (activeAbortController) {
+      activeAbortController.abort();
+    }
+    console.log("\n\x1B[33m[relay]\x1B[0m Disconnected. Bye!");
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  while (!isShuttingDown) {
+    try {
+      activeAbortController = new AbortController();
+      console.log(`\x1B[90mConnecting to Quasar Cloud SSE stream...\x1B[0m`);
+      const response = await fetch(listenUrl, {
+        method: "GET",
+        headers: {
+          Accept: "text/event-stream",
+          "Cache-Control": "no-cache"
+        },
+        signal: activeAbortController.signal
+      });
+      if (!response.ok) {
+        if (response.status === 401) {
+          console.error(
+            `\x1B[31m\u2716 Unauthorized (401):\x1B[0m Invalid webhook signing secret. Check your QUASAR_WEBHOOK_SECRET.`
+          );
+          process.exit(1);
+        }
+        if (response.status === 404) {
+          console.error(
+            `\x1B[31m\u2716 Endpoint Not Found (404):\x1B[0m No webhook endpoint found matching this signing secret.`
+          );
+          process.exit(1);
+        }
+        const errText = await response.text();
+        throw new Error(`HTTP ${response.status} ${response.statusText}: ${errText}`);
+      }
+      if (!response.body) {
+        throw new Error("No readable stream returned by server.");
+      }
+      console.log(`\x1B[32m\u2714 Connected!\x1B[0m Ready and listening for events...`);
+      reconnectDelay = 1e3;
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder("utf-8");
+      let buffer = "";
+      while (!isShuttingDown) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        let currentEvent = "message";
+        let currentData = "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) {
+            if (currentData) {
+              await handleSseMessage(currentEvent, currentData, forwardTo);
+              currentEvent = "message";
+              currentData = "";
+            }
+            continue;
+          }
+          if (trimmed.startsWith("event:")) {
+            currentEvent = trimmed.slice(6).trim();
+          } else if (trimmed.startsWith("data:")) {
+            const dataLine = trimmed.slice(5).trim();
+            currentData = currentData ? `${currentData}
+${dataLine}` : dataLine;
+          }
+        }
+      }
+    } catch (err) {
+      if (isShuttingDown) break;
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`\x1B[33m[warn]\x1B[0m Connection lost (${message}). Reconnecting in ${reconnectDelay}ms...`);
+      await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
+      reconnectDelay = Math.min(reconnectDelay * 2, 15e3);
+    }
+  }
+}
+async function handleSseMessage(event, rawData, forwardTo) {
+  if (event === "ping" || rawData === ":keepalive" || rawData.startsWith(":")) {
+    return;
+  }
+  try {
+    const payload = JSON.parse(rawData);
+    if (event === "connected") {
+      return;
+    }
+    if (event === "payload" || event === "webhook" || event === "message") {
+      const dataObj = payload;
+      const deliveryId = dataObj.deliveryId || dataObj.id || "";
+      const eventType = dataObj.event || dataObj.eventType || dataObj.action || "webhook";
+      const forwardedData = dataObj.data !== void 0 ? dataObj.data : dataObj.payload !== void 0 ? dataObj.payload : dataObj;
+      const signature = dataObj.signature || "";
+      const startTime = Date.now();
+      const timeStr = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      try {
+        const res = await fetch(forwardTo, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-quasar-signature": signature,
+            "x-quasar-event": eventType,
+            "x-quasar-delivery-id": deliveryId
+          },
+          body: JSON.stringify(forwardedData)
+        });
+        const duration = Date.now() - startTime;
+        if (res.ok) {
+          console.log(
+            `\x1B[90m${timeStr}\x1B[0m \x1B[32m[${res.status} OK]\x1B[0m \x1B[1m${eventType}\x1B[0m \u2794 ${forwardTo} \x1B[90m(${duration}ms)\x1B[0m`
+          );
+        } else {
+          console.warn(
+            `\x1B[90m${timeStr}\x1B[0m \x1B[31m[${res.status} ${res.statusText}]\x1B[0m \x1B[1m${eventType}\x1B[0m \u2794 ${forwardTo} \x1B[90m(${duration}ms)\x1B[0m`
+          );
+        }
+      } catch (postErr) {
+        const errMsg = postErr instanceof Error ? postErr.message : String(postErr);
+        console.error(
+          `\x1B[90m${timeStr}\x1B[0m \x1B[31m[FAIL]\x1B[0m \x1B[1m${eventType}\x1B[0m \u2794 Could not reach ${forwardTo}: ${errMsg}`
+        );
+        console.error(`       \x1B[33mTip: Make sure your local application is running on ${forwardTo}\x1B[0m`);
+      }
+    }
+  } catch {
+  }
+}
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  const options = parseArgs(rawArgs);
+  if (options.help || rawArgs.length === 0 && !options.version) {
+    printHelp();
+    return;
+  }
+  if (options.version) {
+    console.log(`@tuwaio/quasar-sdk v${CLI_VERSION}`);
+    return;
+  }
+  if (options.command !== "listen") {
+    console.error(`\x1B[31m\u2716 Unknown command:\x1B[0m "${options.command}". Did you mean "listen"?`);
+    console.log(`Run \x1B[1mnpx @tuwaio/quasar-sdk --help\x1B[0m for available commands.`);
+    process.exit(1);
+  }
+  const env = loadEnv(options.envFile);
+  const secret = options.secret || process.env.QUASAR_WEBHOOK_SECRET || env.QUASAR_WEBHOOK_SECRET;
+  const forwardTo = options.forwardTo || process.env.QUASAR_WEBHOOK_FORWARD_TO || env.QUASAR_WEBHOOK_FORWARD_TO || DEFAULT_FORWARD_URL;
+  const apiUrl = options.apiUrl || process.env.NEXT_PUBLIC_QUASAR_BASE_URL || env.NEXT_PUBLIC_QUASAR_BASE_URL || process.env.QUASAR_BASE_URL || env.QUASAR_BASE_URL || DEFAULT_API_URL;
+  if (!secret) {
+    console.error(`
+\x1B[31m\u2716 Missing Webhook Signing Secret\x1B[0m
+  The local relay requires your webhook endpoint signing secret (starting with whsec_).
+
+\x1B[1mHow to fix:\x1B[0m
+  1. Provide via command-line argument:
+     $ npx @tuwaio/quasar-sdk listen --secret whsec_...
+
+  2. Or add to your local .env / .env.local file:
+     QUASAR_WEBHOOK_SECRET=whsec_...
+`);
+    process.exit(1);
+  }
+  await runListen({
+    secret,
+    forwardTo,
+    apiUrl
+  });
+}
+if (!process.env.VITEST) {
+  void main().catch((err) => {
+    console.error("\x1B[31mFatal error:\x1B[0m", err);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLI_VERSION,
+  DEFAULT_API_URL,
+  DEFAULT_FORWARD_URL,
+  handleSseMessage,
+  loadEnv,
+  main,
+  parseArgs,
+  parseEnvFile
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tuwaio/quasar-sdk",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "private": false,
   "author": "Oleksandr Tkach",
   "license": "Apache-2.0",
@@ -23,6 +23,10 @@
     "dist",
     "socket.json"
   ],
+  "bin": {
+    "@tuwaio/quasar-sdk": "./dist/cli.cjs",
+    "quasar-sdk": "./dist/cli.cjs"
+  },
   "keywords": [
     "tuwa",
     "web3",