open-index/open-npm huggingface dataset:
npm package: @shaurya2k06/vcrsdk
Description: VCR Protocol SDK — Policy-bound autonomous agent wallets with on-chain verification, ENS integration, x402 payments, and BitGo enforcement.
Author: VCR Protocol
Latest version: 1.1.0

# @vcr-protocol/sdk

The official SDK for the VCR Protocol. Build policy-bound autonomous agent wallets with on-chain verification, ENS integration, x402 payments, and BitGo enforcement.

## Features

- **Policy Management**: Create, validate, and pin VCR policies to IPFS.
- **Verification Engine**: Check spend requests against local or fetched policies (daily limits, whitelists, etc).
- **ENS Integration (ENSIP-25)**: Link agents and policies to human-readable ENS names.
- **ERC-8004 Support**: Register and manage on-chain agent identities.
- **BitGo Integration**: Create and manage highly secure v3 multisig wallets for agents.
- **x402 Payments**: Integrate with the x402 protocol for agent-to-agent and agent-to-human payments.

## Installation

```bash
npm install @vcr-protocol/sdk
```

## Quick Start

### 1. Verify a Spend Request

```typescript
import { canAgentSpend } from '@vcr-protocol/sdk';

const result = await canAgentSpend("agent.eth", {
  amount: "1000000", // 1 USDC (6 decimals)
  token: "USDC",
  recipient: "0x...",
  chain: "base-sepolia"
}, async (ens, token) => {
  // Return current daily spent from your DB
  return "0"; 
});

if (result.allowed) {
  console.log("Agent is authorized to spend!");
} else {
  console.log("Blocked:", result.reason);
}
```

### 2. Create and Pin a Policy

```typescript
import { createPolicy, pinPolicy } from '@vcr-protocol/sdk';

const policy = createPolicy("eip155:11155111:...", {
  maxTransaction: { amount: "5000000", token: "USDC", chain: "base-sepolia" },
  dailyLimit: { amount: "10000000", token: "USDC", chain: "base-sepolia" },
  allowedRecipients: ["0x..."],
  allowedTokens: ["USDC"],
  allowedChains: ["base-sepolia"]
});

const { cid, ipfsUri } = await pinPolicy(policy);
// Link ipfsUri to your ENS name as a 'vcr.policy' text record
```

## Environment Variables

The SDK requires the following environment variables for certain features:

- `PINATA_JWT` & `PINATA_GATEWAY`: For IPFS operations.
- `SEPOLIA_RPC_URL`: For on-chain lookups and registrations.
- `BITGO_ACCESS_TOKEN`, `BITGO_ENTERPRISE_ID`, `BITGO_WALLET_PASSPHRASE`: For BitGo wallet management.

## Publishing

To publish a new version:

1. Increment version in `package.json`.
2. Run `npm run build`.
3. Run `npm publish --access public`.

## License

MIT
npm package: @shaveko/jsonpatch
Description: This is simple CLI tool to create JSONPatch files and apply JSONPatch files to json.
Author: Andrey Shaveko
Latest version: 1.0.0

### Description

This is simple CLI tool to create JSONPatch files and apply JSONPatch files to json.

See [http://jsonpatch.com/](jsonpatch.com/)

### Installation

### Usage

`jsonpatch diff <sourceJson> <targetJson> -o <outputPatchJson>`

`jsonpatch apply <sourceJson> <patchJson> -o <targetJson>`
npm package: @shavenzov/ngx-translate-extract-marker
Description: Function to manually mark strings to be extracted using @shavenzov/ngx-translate-extract
Author: Shavenzov Denis
Latest version: 1.0.2

## Mark strings for extraction using a marker function
If, for some reason, you want to extract strings not passed directly to `TranslateService`'s `get()` or `instant()` methods, you can wrap them in a custom marker function to let `ngx-translate-extract` know you want to extract them.

It's the fork of [@biesbjerg/ngx-translate-extract-marker](https://github.com/biesbjerg/ngx-translate-extract-marker).
In this version added string **context** and **comment** support feature.

Install marker function:
`npm install @shavenzov/ngx-translate-extract-marker`

```ts
import { marker } from '@shavenzov/ngx-translate-extract-marker';

marker('Extract me');
```

Add the `marker` argument when running the extract script:

`ngx-translate-extract ... --marker marker`

You can alias the marker function if needed:

```ts
import { marker as $ } from '@shavenzov/ngx-translate-extract-marker';

$('Extract me');

//Extract string with specific content and comment to translator
$('Extract me', 'context', 'comment');
```

`ngx-translate-extract ... --marker $`
npm package: @shawbs/ms-ui
Description: A mobile Vue component library
Author: shawbs
Latest version: 0.2.9

# ms-ui

### 参照element-ui实现的一个Vue 移动端组件库


### [文档](https://shawbs.github.io/ms-ui.example.io/#/)

## 安装

```
npm install @shawbs/ms-ui -S
```

### 全部引入

```
import MsUi from "@shawbs/ms-ui";
import "@shawbs/ms-ui/lib/theme/index.css";
Vue.use(MsUi, { size: "small" });
```

### 按需引入
```
//.babelrc 
{
    "plugins": [
        [
        "component",
        {
            libraryName: "@shawbs/ms-ui",
            styleLibraryName: "theme",
        }
        ]
    ]
}
```
```
import {
  Tabbar,
  TabbarItem,
  Layout,
  Button,
  ButtonGroup,
  Row,
  Col,
  Icon,
  Popup,
  MessageBox,
  Toast,
  Loading,
  Form,
  FormItem,
  Input,
  Img,
  Link,
  Radio,
  RadioGroup,
  SideMenu
} from "@shawbs/ms-ui";

Vue.component(Tabbar.name, Tabbar);
Vue.component(TabbarItem.name, TabbarItem);
Vue.use(Layout);
Vue.component(Button.name, Button);
Vue.component(ButtonGroup.name, ButtonGroup);
Vue.component(Icon.name, Icon);
Vue.component(Row.name, Row);
Vue.component(Col.name, Col);
Vue.component(Popup.name, Popup);
Vue.use(MessageBox);
Vue.use(Toast);
Vue.use(Loading);
Vue.component(Form.name, Form);
Vue.component(FormItem.name, FormItem);
Vue.component(Input.name, Input);
Vue.component(Img.name, Img);
Vue.component(Link.name, Link);
Vue.component(Radio.name, Radio);
Vue.component(RadioGroup.name, RadioGroup);
Vue.component(SideMenu.name, SideMenu);
```

### 国际化

```
import MsUi from "@shawbs/ms-ui";
import "@shawbs/ms-ui/lib/theme/index.css";
import en from "@shawbs/ms-ui/lib/locale/lang/en";

Vue.use(MsUi, { locale: en });
```

### 主题化

```
import MsUi from "@shawbs/ms-ui";
import "./ms-ui.scss";
Vue.use(MsUi);
```
ms-ui.scss
```
/* 改变主题色变量 */
$--color-primary: teal;

/* 改变 icon 字体路径变量，必需 */
$--font-path: '~@shawbs/ms-ui/lib/theme/font';

@import "~@shawbs/ms-ui/main/packages/theme/src/index";
```
npm package: @shawerestart/layout
Description: graph layout algorithm
Latest version: 0.1.42

## About

Layout algorithms for AntV

## Installation

```shell
# npm
$ npm install @antv/layout --save

# yarn
$ yarn add @antv/layout
```

## Usage

```ts
import { GridLayout } from '@antv/layout'

const model = {
  nodes: [
    {
      id: 'node1',
      x: 0,
      y: 0,
    }, {
      id: 'node2',
      x: 20,
      y: 20,
    },
  ],
  edges: [
    {
      source: 'node1',
      target: 'node2',
    },
  ],
}

const gridLayout = new GridLayout({
  type: 'grid',
  width: 600,
  height: 400,
  rows: 4,
  cols: 4,
})

const newModel = gridLayout.layout(model)

```

## Documentation

- [G6 Layout](https://g6.antv.vision/zh/docs/api/graphLayout/guide)

## License

The scripts and documentation in this project are released under the [MIT License](LICENSE).
npm package: @shawkatkabbara/parse-server-azure-config
Description: A module to generate configuration for parse server on azure
Author: Matt Mason
Latest version: 1.0.6

## Parse Server Azure Config 

A package to simplify configuration of parse server on azure managed services.

Exports an object with default configurations for storage, push, server, and dashboard.
```js
let config = require('parse-server-azure-config');
let ParseServer = require('parse-server').ParseServer;
let ParseDashboard = require('parse-dashboard');
let express = require('express');

let options = {
  defaults: 'config.js', // file to load with default user configuration
  secrets: 'secrets.js'  // file to load secrets
}

let {
  server,     // parse server configuration options
  storage,    // parse server azure storage configuration options
  push,       // parse server azure push configuration options
  dashboard   // parse dashboard configuration options
} = config(__dirname, options);

let app = express();
app.use('/parse', new ParseServer(server));
app.use('/parse-dashboard', ParseDashboard(dashboard));

app.listen(process.env.PORT);
```
npm package: @shawkatkabbara/parse-server-azure-push
Description: A Parse Server push adapter using notification hubs
Latest version: 1.0.4

[![Build Status](https://travis-ci.org/mamaso/parse-server-azure-push.svg?branch=master)](https://travis-ci.org/mamaso/parse-server-azure-push)
[![Dependency Status](https://david-dm.org/mamaso/parse-server-azure-push.svg)](https://david-dm.org/mamaso/parse-server-azure-push)

# Parse Server Azure Push

This module provides push capabilities for parse server via azure notification hubs.

Add to your parse app like so:
```js
var azurePushAdapter = require('parse-server-azure-push');
var ParseServer = require('parse-server').ParseServer;
var express = require('express');

var server = new ParseServer({
    //... other config values ...
    push: azurePushAdapter({
        ConnectionString: 'notification hub connection string',
        HubName: 'notification hub name'
    })
});
```

If you do not want to explicitly specify a connection string or hub name,
they can be specified via environment variables:
  * ConnectionString: process.env.CUSTOMCONNSTR_MS_NotificationHubConnectionString
  * HubName: process.env.MS_NotificationHubName

# Sending WNS Pushes

This module has the capability to send pushes to Windows devices.  The default behavior is to send toast notifications:

```js
Parse.Cloud.define('myPushFunction', (req, res) => {
    // sends a toast notification with text 'my toast notification'
    Parse.Push.send({
        channels: [ 'someChannel' ],
        data: {
            alert: 'my toast notification'
        }
    }, { useMasterKey: true })
    .then(res.success)
    .catch(res.error);
});
```

If you would like to send more advanced WNS notifications, you can through the use of the 'wns' object:

```js
// sends a raw notification with custom wns header
Parse.Push.send({
    channels: [ 'someChannel' ],
    data: {
        alert: 'apple or gcm alert'     // ignored if 'wns.data' exists for windows installations
    },
    wns: {
        type: 'raw',                    // adds the X-WNS-Type: 'wns/raw' header
        data: 'my raw notification',    // the wns payload
        headers: {                      // custom headers to be sent to WNS
            'X-WNS-Cache-Policy': 'cache'
        }
    }
}, { useMasterKey: true });
```
npm package: @shawkatkabbara/parse-server-azure-storage
Description: Use Azure Blob Storage with Parse Server
Latest version: 1.1.2

# Azure Storage Files Adapter for Parse Server
<a href="https://www.npmjs.com/package/parse-server-azure-storage"><img src="https://badge.fury.io/js/parse-server-azure-storage.svg" alt="npm version" height="18"></a> <a href="https://david-dm.org/felixrieseberg/parse-server-azure-storage"><img src="https://david-dm.org/felixrieseberg/parse-server-azure-storage.svg" alt="dependencies" height="18px"></a> <a href="https://travis-ci.org/felixrieseberg/parse-server-azure-storage"><img src="https://travis-ci.org/felixrieseberg/parse-server-azure-storage.svg?branch=master"></a> <a href="https://codecov.io/github/felixrieseberg/parse-server-azure-storage?branch=master"><img src="https://codecov.io/github/felixrieseberg/parse-server-azure-storage/coverage.svg?branch=master" alt="Coverage via Codecov" /></a>
This module allows you to use Azure Blob Storage with the open source Parse Server, brought to you by your friends in Microsoft's Open Source Engineering team.

## Usage
First, ensure that you have an Azure Blob Storage account, with a container setup. Then, install the adapter:

```
npm install parse-server-azure-storage
```

If you're using `parse-server` at version 2.2 (or below), please install with:

```
npm install parse-server-azure-storage@0.3.0
```

#### Direct Access
By default, Parse will proxy all files - meaning that your end user accesses the files via your open source Parse-Server, not directly by going to Azure Blob storage. This is useful if you want files to only be accessible for logged in users or have otherwise security considerations.

If your files can be public, you'll win performance by accessing files directly on Azure Blob Storage. To enable, ensure that your container's security policy is set to `blob`. Then, in your `AzureStorageAdapter` options, set `directAccess: true`.

```
var ParseServer         = require('parse-server').ParseServer;
var AzureStorageAdapter = require('parse-server-azure-storage').AzureStorageAdapter;

var account = 'YOUR_AZURE_STORAGE_ACCOUNT_NAME';
var container = 'YOUR_AZURE_STORAGE_CONTAINER_NAME';
var options = {
    accessKey: 'YOUR_ACCESS_KEY',
    directAccess: false // If set to true, files will be served by Azure Blob Storage directly
}

var api = new ParseServer({
  appId: process.env.APP_ID || 'myAppId',
  masterKey: process.env.MASTER_KEY || '', //Add your master key here. Keep it secret!
  serverURL: process.env.SERVER_URL || 'http://localhost:1337'
  (...)
  filesAdapter: new AzureStorageAdapter(account, container, options);
});
```

## License
The MIT License (MIT); Copyright (c) 2016 Felix Rieseberg and Microsoft Corporation. Please see `LICENSE` for details.