open-index/open-npm huggingface dataset:
npm package: @solobank/cli
Description: CLI for AI agent bank accounts on Solana — init, address, balance, send, pay
Author: solobank
Latest version: 4.0.2

# @solobank/cli

Compact Solana CLI for the `solobank` stack.

## Install

```bash
pnpm add -g @solobank/cli
```

## Commands

```bash
solobank init
solobank address
solobank balance
solobank send 0.1 RECIPIENT --asset SOL
solobank send 2.5 RECIPIENT --asset USDC
solobank swap-quote 25 USDC SOL
solobank swap 25 USDC SOL --slippage-bps 50
solobank lend-rates USDC
solobank lend 100 USDC --protocol auto
solobank borrow 10 USDC --protocol marginfi
solobank repay 5 USDC --protocol marginfi
solobank withdraw 20 USDC --protocol marginfi
solobank rebalance 50 USDC --protocol marginfi --target-protocol auto --min-apy-delta 0.005
solobank pay https://api.example.com/protected --max-price 0.05
solobank mcp
```

`solobank mcp` prints a ready-to-paste stdio config snippet for `@solobank/mcp`.

For position-specific actions you can also pin the exact target:

```bash
solobank borrow 10 USDC --protocol marginfi --bank <BANK_ADDRESS>
solobank withdraw 20 USDC --protocol kamino --market <MARKET_ADDRESS> --reserve <RESERVE_ADDRESS>
```

## Environment

```bash
export SOLOBANK_RPC_URL=https://api.devnet.solana.com
export SOLOBANK_JUP_BASE_URL=https://lite-api.jup.ag
```

Optional for Jupiter Pro:

```bash
export SOLOBANK_JUP_API_KEY=...
```
npm package: @solobank/mcp
Description: Minimal MCP server for Solobank agents on Solana — address, balance, send, and MPP pay tools
Author: solobank
Latest version: 4.0.2

# @solobank/mcp

Minimal MCP server for a `@solobank/sdk` agent on Solana.

The package keeps the scope deliberately small:
- `solobank_address`
- `solobank_balance`
- `solobank_send`
- `solobank_pay`

The package uses stdio transport and is intended for Claude Desktop, Cursor, Windsurf, or any MCP client.

## Install

```bash
pnpm add @solobank/mcp @solobank/sdk
```

## Run

```bash
solobank-mcp --rpc-url https://api.devnet.solana.com
```

Optional flags:
- `--keypair /path/to/id.json`
- `--rpc-url https://...`

## MCP Config

```json
{
  "mcpServers": {
    "solobank": {
      "command": "solobank-mcp",
      "args": ["--rpc-url", "https://api.devnet.solana.com"]
    }
  }
}
```

## Programmatic Usage

```ts
import { startMcpServer } from '@solobank/mcp';

await startMcpServer({
  rpcUrl: 'https://api.devnet.solana.com',
  keypairPath: '/path/to/id.json',
});
```

## Notes

- The server resolves its agent through `@solobank/sdk`.
- If you already have an initialized agent object, pass it directly to `createMcpServer({ agent })`.
- Tool responses are returned as compact JSON text blocks for MCP clients.
npm package: @solobank/mpp-solana
Description: Solana USDC payment method for the Machine Payments Protocol (MPP)
Author: solobank
Latest version: 2.0.1

# @solobank/mpp-solana

Solana USDC payment method for the [Machine Payments Protocol (MPP)](https://mpp.dev), built on `@solana/kit` v2 with SPL Token transfers.

[![CI](https://github.com/decentrathon/mpp-solana/actions/workflows/ci.yml/badge.svg)](https://github.com/decentrathon/mpp-solana/actions/workflows/ci.yml)

## Installation

```bash
pnpm add @solobank/mpp-solana mppx @solana/kit
```

## Accept Payments (Server)

```ts
import { Mppx } from 'mppx';
import { solanaServer, SOLANA_USDC_MINT } from '@solobank/mpp-solana';

const mppx = Mppx.create({
  methods: [
    solanaServer({
      currency: SOLANA_USDC_MINT,
      recipient: 'YOUR_SOLANA_WALLET',
    }),
  ],
});
```

The server verifies submitted Solana signatures against RPC using instruction-level checks and token balance deltas.

## Make Payments (Client)

```ts
import { createKeyPairSignerFromBytes } from '@solana/kit';
import { Mppx } from 'mppx/client';
import { solanaClient } from '@solobank/mpp-solana';

const signer = await createKeyPairSignerFromBytes(secretKeyBytes);

const mppx = Mppx.create({
  methods: [
    solanaClient({
      rpcUrl: 'https://api.mainnet-beta.solana.com',
      signer,
    }),
  ],
});
```

The client:

- Loads all SPL token accounts for the requested mint
- Builds one or more `transferChecked` instructions via `@solana-program/token`
- Creates the recipient ATA idempotently if needed
- Signs, validates size, and broadcasts the transaction
- Returns the Solana signature as the MPP credential

## Exports

```ts
// Client
import { solanaClient } from '@solobank/mpp-solana';
// or
import { solanaClient } from '@solobank/mpp-solana/client';

// Server
import { solanaServer } from '@solobank/mpp-solana/server';

// Utilities
import {
  SOLANA_USDC_MINT,
  USDC_DECIMALS,
  parseAmountToRaw,
  fetchTokenAccounts,
  buildTransferPlan,
} from '@solobank/mpp-solana';
```

## Development

```bash
pnpm install
pnpm typecheck    # Type checking
pnpm test         # 22 unit tests
pnpm build        # Build ESM + CJS + types
```

## Tech Stack

- `@solana/kit` v2 — RPC, transaction building, signing
- `@solana-program/token` — SPL token instructions (transferChecked, ATA)
- `mppx` — MPP protocol framework
- `vitest` — Testing
- `tsup` — Build (ESM + CJS)

## License

MIT
npm package: @solobank/sdk
Description: TypeScript SDK for AI agent bank accounts on Solana — wallet, send, pay
Author: solobank
Latest version: 4.0.2

# @solobank/sdk

SDK for the `solobank` stack on Solana. It focuses on the practical core:
- local wallet bootstrap
- SOL and USDC balances
- native transfers
- Jupiter swaps
- lending APY discovery across Kamino and marginfi
- auto-routing deposits to the best supply APY
- lifecycle actions for lending positions: borrow, repay, withdraw, rebalance
- MPP payments through the `@solobank/mpp-solana` package

## Install

```bash
pnpm add @solobank/sdk @solobank/mpp-solana
```

## Quick Start

```ts
import { Solobank } from '@solobank/sdk';

await Solobank.init();

const agent = await Solobank.create();
const balance = await agent.getBalance();

console.log(balance.address, balance.sol, balance.usdc);
```

## Send Funds

```ts
await agent.send({
  asset: 'USDC',
  amount: 2.5,
  to: 'RECIPIENT_PUBLIC_KEY',
});
```

## Pay MPP-Protected APIs

```ts
const result = await agent.pay({
  url: 'https://api.example.com/protected',
  maxPrice: 0.05,
});
```

## Quote And Execute Swaps

```ts
const quote = await agent.getSwapQuote({
  amount: 25,
  fromAsset: 'USDC',
  toAsset: 'SOL',
});

const result = await agent.swap({
  amount: 25,
  fromAsset: 'USDC',
  toAsset: 'SOL',
  slippageBps: 50,
});
```

## Discover Best Lending APY

```ts
const rates = await agent.getLendingRates({
  asset: 'USDC',
  protocol: 'auto',
});

const best = rates[0];
```

## Lend Into The Best Opportunity

```ts
const result = await agent.lend({
  asset: 'USDC',
  amount: 100,
  protocol: 'auto',
});
```

`protocol: 'auto'` currently compares `marginfi` and `Kamino` supply APY for the requested asset.

## Lending Lifecycle

```ts
await agent.borrow({
  asset: 'USDC',
  amount: 25,
  protocol: 'marginfi',
});

await agent.repay({
  asset: 'USDC',
  amount: 5,
  protocol: 'marginfi',
});

await agent.withdraw({
  asset: 'USDC',
  amount: 20,
  protocol: 'marginfi',
});

await agent.rebalance({
  asset: 'USDC',
  amount: 50,
  protocol: 'marginfi',
  targetProtocol: 'auto',
  minApyDelta: 0.005,
});
```

If you need a precise target, you can also pass `marketAddress`, `bankAddress`, or `reserveAddress`.

## Environment

```bash
export SOLOBANK_RPC_URL=https://api.devnet.solana.com
export SOLOBANK_JUP_BASE_URL=https://lite-api.jup.ag
```

If you use Jupiter Pro, also set:

```bash
export SOLOBANK_JUP_API_KEY=...
```

## Exports

```ts
import {
  Solobank,
  SUPPORTED_ASSETS,
  formatUsd,
  truncateAddress,
  walletExists,
} from '@solobank/sdk';
```
npm package: @solobrands/token-library
Description: Solobrands design tokens should be link to figma.
Author: Shaquille Galanto - The Form Factory
Latest version: 1.1.140

## Installation

### Authenticate first

```bash
  npm login
```

### Install

```bash
  yarn add @solobrands/token-library
```

## How to use scss tokens

```css
@use '/node-modules/@solobrands/token-library/dist/scss/isle' as *;

.element {
  color: $space-0;
}
```

## How to use scss compositions

```css
@use '/node-modules/@solobrands/token-library/dist/scss/isle' as *;

.element {
  @include %button-text-md;
}
```
npm package: @solocker/vesting
Description: ## Quickstart
Latest version: 0.0.7

# Solocker JS bindings

## Quickstart

Contract address on Devnet

```
1ocCqQWucYtpsXuWnMwxf54BsNHmeXGx2MVNvY122oT 
```

Contract address on Mainnet

```
1ocCqQWucYtpsXuWnMwxf54BsNHmeXGx2MVNvY122oT 
```

The code allows you to

- Create vesting instructions for any SPL token: `createCreateInstruction`
- Create unlock instructions: `createUnlockInstruction`
- Change the destination of the vested tokens: `createChangeDestinationInstruction`

(To import Solana accounts created with [Sollet](https://sollet.io) you can use `getAccountFromSeed`)

```
Seed 9043936629442508205162695100279588102353854608998701852963634059
Vesting contract account pubkey:  r2p2mLJvyrTzetxxsttQ54CS1m18zMgYqKSRzxP9WpE
contract ID:  90439366294425082051626951002795881023538546089987018529636340fe
✅ Successfully created vesting instructions
🚚 Transaction signature: 2uypTM3QcroR7uk6g9Y4eLdniCHqdQBDq4XyrFM7hCtTbb4rftkEHMM6vJ6tTYpihYubHt55xWD86vHB857bqXXb

Fetching contract  r2p2mLJvyrTzetxxsttQ54CS1m18zMgYqKSRzxP9WpE
✅ Successfully created unlocking instructions
🚚 Transaction signature: 2Vg3W1w8WBdRAWBEwFTn2BtMkKPD3Xor7SRvzC193UnsUnhmneUChPHe7vLF9Lfw9BKxWH5JbbJmnda4XztHMVHz

Fetching contract  r2p2mLJvyrTzetxxsttQ54CS1m18zMgYqKSRzxP9WpE
✅ Successfully changed destination
🚚 Transaction signature: 4tgPgCdM5ubaSKNLKD1WrfAJPZgRajxRSnmcPkHcN1TCeCRmq3cUCYVdCzsYwr63JRf4D2K1UZnt8rwu2pkGxeYe
```
npm package: @solomang/alert.js
Description: A simple toast/alert notification library
Author: Salman Shahid
Latest version: 1.0.2

This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).

## Getting Started

First, run the development server:

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.

This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.

## Learn More

To learn more about Next.js, take a look at the following resources:

- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!

## Deploy on Vercel

The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.
npm package: @solomid/node-gg
Description: Node.js Client for champion.gg API
Latest version: 3.0.1

# Node.js Client for the Champion.GG API

[![NPM](https://nodei.co/npm/@solomid/node-gg.png?mini=true)](https://www.npmjs.com/package/@solomid/node-gg)

[![Build Status via Travis CI](https://travis-ci.org/solomidnet/championgg-api-node.svg?branch=master)](https://travis-ci.org/solomidnet/championgg-api-node)

The official Champion.GG API Node.js Client.

# installation
  ```
  npm i @solomid/node-gg
  ```
  
  If you really need an ES5 version:
  ```
  npm i @solomid/node-gg@1.1.0
  ```

# usage
First, instantiate the wrapper with your api key
  ```
  const GG = require('node-gg');
  const gg = GG.init('YOUR_KEY');
  ```

Then you gain access to all current endpoints of the API! All but initialization require a callback function and some also require either `role` or `champion_id`, along with an optional object with ...options. These options are passed as query string params and are `page`, `limit`, `elo`, `sort` and `champData`. For more details on these parameters, please refer to the Champion.GG API documentation.

The methods are:

Method | Parameters |
------ | ---------- |
`.init`| `api_key`  |
`.statistics.overall` | `options`, `cb` |
`.statistics.general` | `options`, `cb` |
`.champions.all` | `options`, `callback` |
`.champions.specific` | `champId`, `options`, `callback` |
`.champions.specificRole` | `champId`, `role`, `options`, `callback` |
`.champions.specificMatchup` | `champ1Id`, `champ2Id`, `role`, `options`, `callback` |


# tests
 ```
 npm test
 ```

## contributing
Feel free to contribute, let's just try to keep it readable :)
npm package: @solominh/mic-recorder-to-mp3
Description: Record your microphone audio input and get an audio/mp3 ouput buffer/blob.
Author: Djalma Araujo
Latest version: 2.2.2

# Microphone Recorder to Mp3

Record your microphone audio input and get an ```audio/mp3``` file in the end.

# Install

## Yarn

```bash
yarn add mic-recorder-to-mp3
```

## npm

```bash
npm install mic-recorder-to-mp3
```

## CDN Usage

You can add via CDN using the address: [https://unpkg.com/mic-recorder-to-mp3@2.2.1](https://unpkg.com/mic-recorder-to-mp3@2.2.1). You can find the minified version in the same address, ex: [https://unpkg.com/mic-recorder-to-mp3@2.2.1/dist/index.min.js](https://unpkg.com/mic-recorder-to-mp3@2.2.1/dist/index.min.js)

**About the version in URL**: Change the URL version to any of our releases, or use https://unpkg.com/mic-recorder-to-mp3 to automatically use the latest version.

# Development

- Watch for changes:

```bash
npm run watch
```

- Regular build:

```bash
npm run build
```

# How to use

```js
const MicRecorder = require('mic-recorder-to-mp3');

// New instance
const recorder = new MicRecorder({
  bitRate: 128
});

// Start recording. Browser will request permission to use your microphone.
recorder.start().then(() => {
  // something else
}).catch((e) => {
  console.error(e);
});

// Once you are done singing your best song, stop and get the mp3.
recorder
.stop()
.getMp3().then(([buffer, blob]) => {
  // do what ever you want with buffer and blob
  // Example: Create a mp3 file and play
  const file = new File(buffer, 'me-at-thevoice.mp3', {
    type: blob.type,
    lastModified: Date.now()
  });

  const player = new Audio(URL.createObjectURL(file));
  player.play();

}).catch((e) => {
  alert('We could not retrieve your message');
  console.log(e);
});
```

- Check the [samples](https://github.com/closeio/mic-recorder-to-mp3/tree/master/samples) folder for more examples.

- [Live example on jsfiddle](https://jsfiddle.net/8u5fbpx6/1/)

## Lamejs Notice

This library uses lamejs as a direct dependency. We build our releases with [lamejs](https://github.com/zhuker/lamejs/) built-in, so you don't need to add another dependency.

Thanks to **@zhuker** for writing the lamejs library.

# License

MIT
npm package: @solomon_ai/pdfium
Description: Universal wrapper for PDFium
Author: Yevhenii Hyzyla
Latest version: 2.1.10

# @hyzyla/pdfium

📃 [Documentation](https://pdfium.js.org/docs/intro)

TypeScript/JavaScript wrapper for the PDFium library:

- ⬇️ [pdfium](https://pdfium.googlesource.com/pdfium/) - source code of the PDFium library, developed by Google and used in Chrome.
- ⬇️ [pdfium-lib](https://github.com/paulocoutinhox/pdfium-lib) - project to compile PDFium library to multiple platforms, including WebAssembly.
- 📍 [@hyzyla/pdfium](https://github.com/hyzyla/pdfium) - (you are here)
 TypeScript/JavaScript wrapper for the WebAssembly build of PDFium library.

# Features
-  📦 Zero dependencies - PDFium library is compiled to WebAssembly and bundled with the package.
- 🚀 Fast - PDFium can be faster than PDF.js, because it's originally written in C++ and compiled to WebAssembly, while PDF.js is entirely written in JavaScript.
- 🔒 Type-safe - TypeScript definitions are included.
- 🗼 Works in browser and Node.js

## Installation

```sh
# yarn add @hyzyla/pdfium
# pnpm install @hyzyla/pdfium
npm install @hyzyla/pdfium
```

## Usage

```ts
import { PDFiumLibrary } from "@hyzyla/pdfium";
import { promises as fs } from 'fs';
import sharp from 'sharp';


/**
 * For this and the following examples, we will use "sharp" library to convert
 * the raw bitmap data to PNG images. You can use any other library or write
 * your own function to convert the raw bitmap data to PNG images.
 */
async function renderFunction(options: PDFiumPageRenderOptions) {
  return await sharp(options.data, {
    raw: {
      width: options.width,
      height: options.height,
      channels: 4,
    },
  })
    .png()
    .toBuffer();
}


async function main() {
  const buff = await fs.readFile('test2.pdf');

  // Initialize the library, you can do this once for the whole application
  // and reuse the library instance.
  const library = await PDFiumLibrary.init();

  // Load the document from the buffer
  // You can also pass "password" as the second argument if the document is encrypted.
  const document = await library.loadDocument(buff);

  // Iterate over the pages, render them to PNG images and
  // save to the output folder
  for (const page of document.pages()) {
    console.log(`${page.number} - rendering...`);

    // Render PDF page to PNG image
    const image = await page.render({
      scale: 3, // 3x scale (72 DPI is the default)
      render: renderFunction,  // sharp function to convert raw bitmap data to PNG
    });

    // Save the PNG image to the output folder
    await fs.writeFile(`output/${page.number}.png`, Buffer.from(image.data));
  }

  // Do not forget to destroy the document and the library
  // when you are done.
  document.destroy();
  library.destroy();
}

main();
```


## Release

1. Bump version in `package.json`: `npm version patch`
2. Create a new release in GitHub
3. Check status of the [GitHub Actions](https://github.com/hyzyla/pdfium/actions)
npm package: @solomonai/api
Description: <div align="center">     <h1 align="center">@solomonai/api</h1>     <h5>`@solomonai/api` is a TypeScript client for SolomonAI. If you prefer a typed experience over calling HTTP endpoints directly, this SDK is for you.</h5> </div>
Author: Yoan Yomba
Latest version: 0.28.0

<div align="center">
    <h1 align="center">@solomonai/api</h1>
    <h5>`@solomonai/api` is a TypeScript client for SolomonAI. If you prefer a typed experience over calling HTTP endpoints directly, this SDK is for you.</h5>
</div>

<div align="center">
  <a href="https://www.solomonai.com/docs/libraries/ts/sdk/overview">Documentation</a>
</div>
<br/>

## Installation

```bash
npm install @solomonai/api
```

## Quickstart

1.  Create a new SolomonAI Root Key in the settings.
2.  Use the root key to initialize the client:

```ts
import { SolomonAI } from '@solomonai/api'

const solomonai = new SolomonAI({ rootKey: '<SOLOMONAI_ROOT_KEY>' })
```

**Important:** Always keep your root key safe and reset it if you suspect it has been compromised.

## Usage

### Verifying a Key

```ts
import { verifyKey } from '@solomonai/api'

const { result, error } = await verifyKey('key_123')

if (error) {
  console.error(error.message)
  // Handle potential network or bad request error
  // A link to our docs will be in the `error.docs` field
  return
}

if (!result.valid) {
  // Do not grant access
  return
}

// Process request
console.log(result)
```

## Response Format

All methods return either an `error` or a `result` field, never both and never none. This approach helps with proper error handling.

### Success Response

```ts
{
  result: T // The result depends on what method you called
}
```

### Error Response

```ts
{
  error: {
    message: string
    docs: string // URL to relevant documentation
  }
}
```

## Configuration Options

### Base URL

You can customize the base URL for all requests:

```ts
const solomonai = new SolomonAI({
  rootKey: '<SOLOMONAI_ROOT_KEY>',
  baseUrl: 'https://my.domain',
})
```

### Retries

Configure retry behavior for network errors:

```ts
const solomonai = new SolomonAI({
  rootKey: '<SOLOMONAI_ROOT_KEY>',
  retry: {
    attempts: 3,
    backoff: (retryCount) => retryCount * 1000,
  },
})
```

### Disable Telemetry

To opt out of anonymous telemetry data collection:

```ts
const solomonai = new SolomonAI({
  rootKey: '<SOLOMONAI_ROOT_KEY>',
  disableTelemetry: true,
})
```
npm package: @solomonai/cache
Description: <div align="center">     <h1 align="center">@solomonai/cache</h1>     <h5>Cache all the things</h5> </div>
Author: Andreas Thomas
Latest version: 1.14.1

<div align="center">
    <h1 align="center">@solomonai/cache</h1>
    <h5>Cache all the things</h5>
</div>

<div align="center">
  <a href="https://unkey.com/docs/libraries/ts/cache/overview">Documentation</a>
</div>
<br/>

Battle-tested, strongly typed caching with metrics and tracing out of the box.

## Features

- Tiered caching
- Memory Cache
- Cloudflare Cache
- Cloudflare KV (todo)
- Cloudflare R2 (todo)
- Emit metrics

## Quickstart

```bash
npm install @solomonai/cache
```

```ts
import {
  createCache, DefaultStatefulContext } from "@solomonai/cache";
import { MemoryStore, CloudflareStore } from "@solomonai/cache/stores";


// Only required in stateful environments.
// Cloudflare workers or Vercel provide an executionContext for you.
const ctx = new DefaultStatefulContext();

type User = {
  id: string;
  email: string;
};

type Post = {
  slug: string;
  title: string;
  content: string;
  publishedAt: Date;
};

const fresh = 60_000;
const stale = 900_000;

const ctx = new DefaultStatefulContext();

const memory = new MemoryStore({
  persistentMap: new Map(),
});

const cloudflare = new CloudflareStore({
  cloudflareApiKey: "CLOUDFLARE_API_KEY",
  zoneId: "CLOUDFLARE_ZONE_ID",
  domain: "my-domain-on-cloudflare",
});
const cache = createCache({
  account: new Namespace<Account>(ctx, {
    stores: [memory],
    fresh,
    stale,
  }),
  user: new Namespace<User>(ctx, {
    stores: [memory, cloudflare],
    fresh,
    stale,
  }),
});

await cache.user.set("chronark", { id: "chronark", email: "iykyk" });

// This is fully typesafe and will check the stores in the above defined order.
const user = await cache.user.get("chronark");
```

### Stale while revalidate with origin refresh

Add your database query and the cache will return the stale data while revalidating the data in the background.

```ts
const user = await cache.user.swr("chronark", async (id) => {
  return await db.query.users.findFirst({
    where: (table, { eq }) => eq(table.id, id),
  });
});
```


### Documentation

[Read the full documentation](https://unkey.com/docs/libraries/ts/cache/overview)
npm package: @solomonai/hono
Description: <div align="center">     <h1 align="center">@solomonai/hono</h1>     <h5>Hono.js middleware for authenticating API keys</h5> </div>
Author: Andreas Thomas
Latest version: 1.14.1


<div align="center">
    <h1 align="center">@solomonai/hono</h1>
    <h5>Hono.js middleware for authenticating API keys</h5>
</div>

<div align="center">
  Inspired by <a href="https://www.openstatus.dev/blog/secure-api-with-unkey">openstatus.dev/blog/secure-api-with-unkey</a>
</div>
<br/>



Check out the docs at [unkey.dev/docs](https://unkey.com/docs/libraries/ts/hono).


Here's just an example:

```ts
import { Hono } from "hono"
import { UnkeyContext, unkey } from "@solomonai/hono";

const app = new Hono<{ Variables: { unkey: UnkeyContext } }>();

app.use("*", unkey());


app.get("/somewhere", (c) => {
  // access the unkey response here to get metadata of the key etc
  const ... = c.get("unkey")

  return c.text("yo")
})
``
npm package: @solomonai/nextjs
Description: <div align="center">     <h1 align="center">@solomonai/nextjs</h1>     <h5>`@solomonai/nextjs` the official SDK for Next.js. Just use it in your route handlers a direct and type-safe method to verify API keys.</h5> </div>
Author: Andreas Thomas
Latest version: 1.14.1

<div align="center">
    <h1 align="center">@solomonai/nextjs</h1>
    <h5>`@solomonai/nextjs` the official SDK for Next.js. Just use it in your route handlers a direct and type-safe method to verify API keys.</h5>
</div>

<div align="center">
  <a href="https://www.unkey.com/docs/libraries/ts/nextjs">Documentation</a>
</div>
<br/>

## Installation

```bash
npm install @solomonai/nextjs
```

## Quickstart

Protecting API routes is as simple as wrapping them with the ```withUnkey``` handler:

```ts
import { NextRequestWithUnkeyContext, withUnkey } from '@solomonai/nextjs';

export const POST = withUnkey(async (req) => {

  // Process the request here
  // You have access to the verification response using `req.unkey`
  console.log(req.unkey);

  return new Response('Your API key is valid!');
});
```

That’s it! Since this is just handling key verification, there’s no need to specify a root key as an environment variable.

If you want to customize how withUnkey processes incoming requests, you can do so as follows:

## ```getKey```
By default, withUnkey will look for a bearer token located in the ```authorization``` header. If you want to customize this, you can do so by passing a getter in the configuration object:

```ts
export const GET = withUnkey(async (req) => {
  // ...
}, {
	getKey: (req) => new URL(req.url).searchParams.get("key"),
});
```

## ```onError```

You can specify custom error handling. By default errors will be logged to the console, and ```withUnkey``` will return a NextResponse with status 500.

```ts
export const GET = withUnkey(async (req) => {
  // ...
}, {
	onError: async (req, res) => {
      await analytics.trackEvent(`Error ${res.code}: ${res.message}`)
      return new NextResponse("Unkey error", { status: 500 })
    }
});
```

## ```handleInvalidKey```

Specify what to do if Unkey reports that your key is invalid.

```ts
export const GET = withUnkey(async (req) => {
  // ...
}, {
	handleInvalidKey: (req, res) => {
      return new Response("Unauthorized", { status: 401 })
    }
});
```


## Disable telemetry

By default, Unkey collects anonymous telemetry data to help us understand how our SDKs are used.

If you wish to disable this, you can do so by passing a boolean flag to the constructor:

```ts
export const GET = withUnkey(async (req) => {
  // ...
}, { disableTelemetry: true });
```

### Documentation

[Read the full documentation](https://www.unkey.com/docs/libraries/ts/nextjs)
npm package: @solomonai/smb-cli
Description: A CLI for easily shortening URLs with the Dub.co API.
Author: Steven Tey
Latest version: 0.0.13

# `@solomonai/smb-cli`

A CLI for easily shortening URLs with the [Dub.co API](https://dub.co/api).

https://github.com/user-attachments/assets/2ce9fe51-68ab-4e6d-b08d-4da09c17f90e

## Available Commands

| Command                   | Description                                                                                                                                                                                              |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `dub login`               | Log into the DUB platform                                                                                                                                                                                |
| `dub config`              | See your configured workspace credentials                                                                                                                                                                |
| `dub domains`             | Configure your workspace domain                                                                                                                                                                          |
| `dub shorten [url] [key]` | Create a short link. You can preemptively pass the URL and the generated short link key, or go through the CLI prompts.                                                                                  |
| `dub links [options]`     | Search for links in your Dub workspace. Available options include: `-s, --search <search>` to search for a link by name, or `-l, --limit <limit>` to limit the number of links returned (default is 10). |
| `dub help [command]`      | Display help for a specific command                                                                                                                                                                      |

## Running Locally for Development

1. Clone the repository, install dependencies and navigate to the `cli` folder:
   ```bash
   cd packages/cli
   ```
2. Build the package in watch mode:
   ```bash
   pnpm dev
   ```
3. In a separate terminal, navigate to the `cli` folder again and run an [available command](#available-commands):
   ```bash
   pnpm start [command]
   ```
4. See all [available commands](#available-commands) and options:
   ```bash
   pnpm start help
   ```

## Testing Production-like Setup

> **Warning**
> If you have previously installed `@solomonai/smb-cli` globally, uninstall it first to avoid conflicts

1. Clone the repository, install dependencies and navigate to the `cli` folder:
   ```bash
   cd packages/cli
   ```
2. Build the package:
   ```bash
   pnpm build
   ```
3. Link the package globally:
   ```bash
    npm link
   ```
4. Verify the installation:
   ```bash
    dub -v
   ```
5. Run commands:
   ```bash
   dub [command]
   ```
npm package: @solomonai/stripe-sync-graphql-sdk
Description: Type-safe GraphQL SDK for the Stripe Sync Engine API
Author: Oppulence Engineering
Latest version: 1.18.3

# @solomonai/stripe-sync-graphql-sdk

Type-safe GraphQL SDK for the Stripe Sync Engine API.

## Installation

```bash
npm install @solomonai/stripe-sync-graphql-sdk
# or
bun add @solomonai/stripe-sync-graphql-sdk
```

## Usage

```typescript
import { createClient, createSdk } from '@solomonai/stripe-sync-graphql-sdk'

// Create client with your API endpoint and credentials
const client = createClient({
  endpoint: 'https://your-api.com/graphql',
  headers: {
    'x-tenant-id': 'your-tenant-id',
    'x-api-key': 'your-api-key',
  },
})

// Create typed SDK wrappers for common operations
const sdk = createSdk(client)

const { customers } = await sdk.listCustomers({ first: 10 })
console.log(customers?.edges?.[0]?.node?.email)
```

## React Hooks (Adapter-based)

The SDK provides hook factories that can be wired to your query library (for example, React Query):

```typescript
import { createSdk, createSdkReactHooks } from '@solomonai/stripe-sync-graphql-sdk'
import { useQuery, useMutation } from '@tanstack/react-query'

const sdk = createSdk(client)
const hooks = createSdkReactHooks(sdk, { useQuery, useMutation })

// inside a React component
const customerQuery = hooks.useCustomer({ id: 'cus_123' })
const triggerSync = hooks.useTriggerSync()
```

## Available Types

The SDK exports all GraphQL types for type-safe queries:

```typescript
import type { Customer, Subscription, Invoice } from '@solomonai/stripe-sync-graphql-sdk'
```

## Regenerating Types

Types are auto-generated from the GraphQL schema. To regenerate:

```bash
cd packages/fastify-app
bun run graphql:generate
```

## License

MIT
npm package: @solomonai/templates
Description: This package contains document templates that can be used throughout the SMB Financial Management Platform.
Latest version: 0.1.0

# Document Templates

This package contains document templates that can be used throughout the SMB Financial Management Platform.

## Usage

```tsx
import { listValue, aiValue } from '@smb-financial-management-platform/templates';

/ Use the template in your component
const MyComponent = () => {
  return (
    <div>
      {/* Render the template */}
      {listValue}
    </div>
  );
};
```

## Available Templates

The package includes various document templates for:

- AI assistance
- Basic text elements and formatting
- Tables
- Lists
- Media embeds
- And more

These templates can be used as starting points for creating documents in the platform.
npm package: @solorev/currency-input
Description: Based on input-otp by @guilhermerodz
Latest version: 0.1.5

# An accessible & unstyled Currency Input Component

Based on [input-otp@1.4.1](https://github.com/guilhermerodz/input-otp) [@guilhermerodz](https://twitter.com/guilherme_rodz)

Its just a tiny algorithm tweek to the component and removal of autocomplete attribute.
I'll try to remove all the unnecessary stuff later.
Fully compatible with Shadcn Input OTP just change the imports as below

## Usage

```bash
npm install @solorev/currency-input
```

I didn't even bother changing the exports so Import with `{OTPInput}` atm

```diff
+'use client'
-import { OTPInput } from 'input-otp'
+import { OTPInput } from '@solorev/currency-otp'

function MyForm() {
  return <form>
+   <OTPInput maxLength={6} render={({slots})  => (...)} />
  </form>
}
```
npm package: @solorev/start
Description: Modern and scalable routing for React applications
Author: Tanner Linsley
Latest version: 1.91.3

> 🤫 we're cooking up something special!

<img src="https://static.scarf.sh/a.png?x-pxid=d988eb79-b0fc-4a2b-8514-6a1ab932d188" />

# TanStack Start

![TanStack Router Header](https://github.com/tanstack/router/raw/main/media/header.png)

🤖 Type-safe router w/ built-in caching & URL state management for React!

<a href="https://twitter.com/intent/tweet?button_hashtag=TanStack" target="\_parent">
  <img alt="#TanStack" src="https://img.shields.io/twitter/url?color=%2308a0e9&label=%23TanStack&style=social&url=https%3A%2F%2Ftwitter.com%2Fintent%2Ftweet%3Fbutton_hashtag%3DTanStack">
</a><a href="https://discord.com/invite/WrRKjPJ" target="\_parent">
  <img alt="" src="https://img.shields.io/badge/Discord-TanStack-%235865F2" />
</a><a href="https://npmjs.com/package/@tanstack/react-router" target="\_parent">
  <img alt="" src="https://img.shields.io/npm/dm/@tanstack/router.svg" />
</a><a href="https://bundlephobia.com/result?p=@tanstack/react-router" target="\_parent">
  <img alt="" src="https://badgen.net/bundlephobia/minzip/@tanstack/react-router" />
</a><a href="#badge">
    <img alt="semantic-release" src="https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg">
  </a><a href="https://github.com/tanstack/router/discussions">
  <img alt="Join the discussion on Github" src="https://img.shields.io/badge/Github%20Discussions%20%26%20Support-Chat%20now!-blue" />
</a><a href="https://bestofjs.org/projects/router"><img alt="Best of JS" src="https://img.shields.io/endpoint?url=https://bestofjs-serverless.now.sh/api/project-badge?fullName=tanstack%2Frouter%26since=daily" /></a><a href="https://github.com/tanstack/router" target="\_parent">
  <img alt="" src="https://img.shields.io/github/stars/tanstack/router.svg?style=social&label=Star" />
</a><a href="https://twitter.com/tan_stack" target="\_parent">
  <img alt="" src="https://img.shields.io/twitter/follow/tan_stack.svg?style=social&label=Follow @TanStack" />
</a><a href="https://twitter.com/tannerlinsley" target="\_parent">
  <img alt="" src="https://img.shields.io/twitter/follow/tannerlinsley.svg?style=social&label=Follow @TannerLinsley" />
</a>

Enjoy this library? Try the entire [TanStack](https://tanstack.com)! [React Query](https://github.com/tannerlinsley/react-query), [React Table](https://github.com/tanstack/react-table), [React Charts](https://github.com/tannerlinsley/react-charts), [React Virtual](https://github.com/tannerlinsley/react-virtual)

## Visit [tanstack.com/router](https://tanstack.com/router) for docs, guides, API and more!