open-index/open-npm huggingface dataset:
npm package: @humanaccount/sdk
Description: This package provides 2 APIs for using UserOperations:
Latest version: 0.6.2

# SDK to create and send UserOperation 

This package provides 2 APIs for using UserOperations:

- Low-level "walletAPI"
- High-level Provider


## LowLevel API:

### BaseWalletAPI

An abstract base-class to create UserOperation for a contract wallet.

### SimpleAccountAPI

An implementation of the BaseWalletAPi, for the SimpleWallet sample of account-abstraction.

```typescript
owner = provider.getSigner()
const walletAPI = new SimpleAccountAPI({
    provider, 
    entryPointAddress,
    owner,
    factoryAddress
})
const op = await walletAPI.createSignedUserOp({
  target: recipient.address,
  data: recipient.interface.encodeFunctionData('something', ['hello'])
})
```

## High-Level Provider API

A simplified mode that doesn't require a different wallet extension. 
Instead, the current provider's account is used as wallet owner by calling its "Sign Message" operation.

This can only work for wallets that use an EIP-191 ("Ethereum Signed Message") signature (like our sample SimpleWallet)
Also, the UX is not great (the user is asked to sign a hash, and even the wallet address is not mentioned, only the signer)

```typescript
import { wrapProvider } from '@account-abstraction/sdk'

//use this account as wallet-owner (which will be used to sign the requests)
const aaSigner = provider.getSigner()
const config = {
  chainId: await provider.getNetwork().then(net => net.chainId),
  entryPointAddress,
  bundlerUrl: 'http://localhost:3000/rpc'
} 
const aaProvider = await wrapProvider(provider, config, aaSigner)
const walletAddress = await aaProvider.getSigner().getAddress()

// send some eth to the wallet Address: wallet should have some balance to pay for its own creation, and for calling methods.

const myContract = new Contract(abi, aaProvider)

// this method will get called from the wallet address, through account-abstraction EntryPoint
await myContract.someMethod()
```
npm package: @humanagency/ha-react
Description: Human Agency React components library
Author: valdemarua
Latest version: 1.0.23

# ha-react

> Human Agency React components library

[![NPM](https://img.shields.io/npm/v/@humanagency/ha-react.svg)](https://www.npmjs.com/package/@humanagency/ha-react)

## Install

```bash
yarn add @humanagency/ha-react
```

## Usage

```jsx
import React from 'react'

import { MyComponent } from '@humanagency/ha-react'

const Example = () => {
  return <MyComponent />
}
```

## License

MIT © [valdemarua](https://github.com/valdemarua)
npm package: @humanagencyp/hap-core
Description: Core types, cryptographic primitives, and verification logic for the Human Agency Protocol
Latest version: 0.4.4

# @humanagencyprotocol/hap-core

Core types, cryptographic primitives, and verification logic for the [Human Agency Protocol](https://humanagencyprotocol.com).

## Install

```bash
npm install @humanagencyprotocol/hap-core
```

## What's included

- **Types** — `AgentProfile`, `AgentBoundsParams`, `AgentContextParams`, execution context schemas, gate questions
- **Frame** — Canonical hashing of bounds and context (`computeBoundsHash`, `computeContextHash`)
- **Attestation** — Ed25519 signing and verification of attestation blobs
- **Gatekeeper** — Execution verification against bounds, context constraints, and cumulative tracking
- **Profiles** — Runtime profile registry (`registerProfile`, `getProfile`, `getAllProfiles`, `clearProfiles`)

## Usage

```typescript
import {
  type AgentProfile,
  computeBoundsHash,
  computeContextHash,
  verify,
  registerProfile,
  getProfile,
} from '@humanagencyprotocol/hap-core';

// Register a profile
registerProfile(profile.id, profile);

// Compute deterministic hashes for bounds and context
const boundsHash = computeBoundsHash(bounds, profile);
const contextHash = computeContextHash(context, profile);

// Verify an execution against bounds and attestations
const result = await verify(
  { frame, attestations, execution, context },
  publicKeyHex,
);

if (result.approved) {
  // Execution is within bounds
}
```

## Constraint types

The gatekeeper enforces three types of constraints from the profile's bounds and context schemas:

| Type | Description | Example |
|---|---|---|
| `max` | Numeric upper bound | `amount_max: 1000` |
| `enum` | Value must be in allowed set | `currency: ["USD", "EUR"]` |
| `subset` | Every item must appear in bound | `allowed_domains: "acme.com,partner.org"` |

## Cumulative tracking

Bounds fields ending in `_daily_max` or `_monthly_max` are checked against cumulative execution logs. The gatekeeper resolves running totals from an `ExecutionLog` interface:

```typescript
interface ExecutionLog {
  sumByWindow(profileId: string, path: string, field: string, window: 'daily' | 'monthly'): Promise<number>;
}
```

## License

MIT
npm package: @humanagencyp/linkedin-mcp
Description: LinkedIn MCP server — publish posts, articles, and media via the LinkedIn API
Author: Andreas Schadauer
Latest version: 1.0.1

# LinkedIn MCP Server

MCP server for publishing posts, articles, and media to LinkedIn. Part of the [Human Agency Protocol](https://humanagencyprotocol.org).

## Tools

| Tool | Description |
|---|---|
| `create_post` | Publish a text post |
| `create_article_post` | Publish a post with a link/article |
| `create_image_post` | Publish a post with an image |
| `get_post` | Get a post by URN |
| `list_posts` | List your recent posts |
| `delete_post` | Delete a post |
| `get_profile` | Get your LinkedIn profile |

## Setup

1. Create a LinkedIn App at [linkedin.com/developers](https://www.linkedin.com/developers/)
2. Add "Share on LinkedIn" and "Sign In with LinkedIn using OpenID Connect" products
3. Set `LINKEDIN_ACCESS_TOKEN` environment variable

## Usage

```bash
npx @humanagencyp/linkedin-mcp
```

Or with the HAP Gateway — add your LinkedIn credentials in the Integrations page.

## Environment Variables

| Variable | Required | Description |
|---|---|---|
| `LINKEDIN_ACCESS_TOKEN` | Yes | OAuth2 access token |

## Token Refresh

LinkedIn access tokens expire after 60 days. Programmatic refresh tokens are only available to approved Marketing Developer Platform partners. For personal use, re-authenticate via the HAP Gateway when the token expires.

## Disclaimer

This software is not affiliated with, endorsed by, or officially connected to LinkedIn or Microsoft. Use of the LinkedIn API is subject to LinkedIn's [API Terms of Use](https://www.linkedin.com/legal/l/api-terms-of-use). You are responsible for complying with LinkedIn's terms and rate limits.

## License

MIT — see [LICENSE](LICENSE). Provided as-is, without warranty or support.