open-index/open-npm huggingface dataset:
npm package: @penclipai/adapter-openclaw-gateway
Description: This document describes how `@penclipai/adapter-openclaw-gateway` invokes OpenClaw over the Gateway protocol.
Latest version: 2026.411.0

# OpenClaw Gateway Adapter

This document describes how `@penclipai/adapter-openclaw-gateway` invokes OpenClaw over the Gateway protocol.

## Transport

This adapter always uses WebSocket gateway transport.

- URL must be `ws://` or `wss://`
- Connect flow follows gateway protocol:
1. receive `connect.challenge`
2. send `req connect` (protocol/client/auth/device payload)
3. send `req agent`
4. wait for completion via `req agent.wait`
5. stream `event agent` frames into Paperclip logs/transcript parsing

## Auth Modes

Gateway credentials can be provided in any of these ways:

- `authToken` / `token` in adapter config
- `headers.x-openclaw-token`
- `headers.x-openclaw-auth` (legacy)
- `password` (shared password mode)

When a token is present and `authorization` header is missing, the adapter derives `Authorization: Bearer <token>`.

## Device Auth

By default the adapter sends a signed `device` payload in `connect` params.

- set `disableDeviceAuth=true` to omit device signing
- set `devicePrivateKeyPem` to pin a stable signing key
- without `devicePrivateKeyPem`, the adapter generates an ephemeral Ed25519 keypair per run
- when `autoPairOnFirstConnect` is enabled (default), the adapter handles one initial `pairing required` by calling `device.pair.list` + `device.pair.approve` over shared auth, then retries once.

## Session Strategy

The adapter supports the same session routing model as HTTP OpenClaw mode:

- `sessionKeyStrategy=issue|fixed|run`
- `sessionKey` is used when strategy is `fixed`

Resolved session key is sent as `agent.sessionKey`.

## Payload Mapping

The agent request is built as:

- required fields:
  - `message` (wake text plus optional `payloadTemplate.message`/`payloadTemplate.text` prefix)
  - `idempotencyKey` (Paperclip `runId`)
  - `sessionKey` (resolved strategy)
- optional additions:
  - all `payloadTemplate` fields merged in
  - `agentId` from config if set and not already in template

## Timeouts

- `timeoutSec` controls adapter-level request budget
- `waitTimeoutMs` controls `agent.wait.timeoutMs`

If `agent.wait` returns `timeout`, adapter returns `openclaw_gateway_wait_timeout`.

## Log Format

Structured gateway event logs use:

- `[openclaw-gateway] ...` for lifecycle/system logs
- `[openclaw-gateway:event] run=<id> stream=<stream> data=<json>` for `event agent` frames

UI/CLI parsers consume these lines to render transcript updates.
npm package: @penclipai/create-paperclip-plugin
Description: Scaffolding tool for creating new Paperclip plugins.
Latest version: 2026.411.0

# @penclipai/create-paperclip-plugin

Scaffolding tool for creating new Paperclip plugins.

```bash
npx @penclipai/create-paperclip-plugin my-plugin
```

Or with options:

```bash
npx @penclipai/create-paperclip-plugin @acme/my-plugin \
  --template connector \
  --category connector \
  --display-name "Acme Connector" \
  --description "Syncs Acme data into Paperclip" \
  --author "Acme Inc"
```

Supported templates: `default`, `connector`, `workspace`  
Supported categories: `connector`, `workspace`, `automation`, `ui`

Generates:
- typed manifest + worker entrypoint
- example UI widget using the supported `@paperclipai/plugin-sdk/ui` hooks
- test file using `@paperclipai/plugin-sdk/testing`
- `esbuild` and `rollup` config files using SDK bundler presets
- dev server script for hot-reload (`paperclip-plugin-dev-server`)

The scaffold intentionally uses plain React elements rather than host-provided UI kit components, because the current plugin runtime does not ship a stable shared component library yet.

Inside this repo, the generated package keeps compatibility imports from `@paperclipai/plugin-sdk*` and resolves them to the workspace packages published as `@penclipai/*`.

Outside this repo, the scaffold keeps those same compatibility imports and snapshots local compatibility tarballs into `.paperclip-sdk/` so the generated plugin can install immediately without waiting for npm publish.

If you want the generated package to target already-published npm artifacts instead, pass `--published`:

```bash
node packages/plugins/create-paperclip-plugin/dist/index.js @acme/my-plugin \
  --output /absolute/path/to/plugins \
  --sdk-path /absolute/path/to/paperclip/packages/plugins/sdk \
  --published
```

That keeps generated plugins compatible with both upstream Paperclip hosts and Paperclip CN hosts without requiring dual-published packages.

## Workflow after scaffolding

```bash
cd my-plugin
pnpm install
pnpm dev       # watch worker + manifest + ui bundles
pnpm dev:ui    # local UI preview server with hot-reload events
pnpm test
```
npm package: @penclipai/mcp-server
Description: Model Context Protocol server for Paperclip.
Latest version: 2026.411.0

# Paperclip MCP Server

Model Context Protocol server for Paperclip.

This package is a thin MCP wrapper over the existing Paperclip REST API. It does
not talk to the database directly and it does not reimplement business logic.

## Authentication

The server reads its configuration from environment variables:

- `PAPERCLIP_API_URL` - Paperclip base URL, for example `http://localhost:3100`
- `PAPERCLIP_API_KEY` - bearer token used for `/api` requests
- `PAPERCLIP_COMPANY_ID` - optional default company for company-scoped tools
- `PAPERCLIP_AGENT_ID` - optional default agent for checkout helpers
- `PAPERCLIP_RUN_ID` - optional run id forwarded on mutating requests

## Usage

```sh
npx -y @paperclipai/mcp-server
```

Or locally in this repo:

```sh
pnpm --filter @paperclipai/mcp-server build
node packages/mcp-server/dist/stdio.js
```

## Tool Surface

Read tools:

- `paperclipMe`
- `paperclipInboxLite`
- `paperclipListAgents`
- `paperclipGetAgent`
- `paperclipListIssues`
- `paperclipGetIssue`
- `paperclipGetHeartbeatContext`
- `paperclipListComments`
- `paperclipGetComment`
- `paperclipListIssueApprovals`
- `paperclipListDocuments`
- `paperclipGetDocument`
- `paperclipListDocumentRevisions`
- `paperclipListProjects`
- `paperclipGetProject`
- `paperclipListGoals`
- `paperclipGetGoal`
- `paperclipListApprovals`
- `paperclipGetApproval`
- `paperclipGetApprovalIssues`
- `paperclipListApprovalComments`

Write tools:

- `paperclipCreateIssue`
- `paperclipUpdateIssue`
- `paperclipCheckoutIssue`
- `paperclipReleaseIssue`
- `paperclipAddComment`
- `paperclipUpsertIssueDocument`
- `paperclipRestoreIssueDocumentRevision`
- `paperclipCreateApproval`
- `paperclipLinkIssueApproval`
- `paperclipUnlinkIssueApproval`
- `paperclipApprovalDecision`
- `paperclipAddApprovalComment`

Escape hatch:

- `paperclipApiRequest`

`paperclipApiRequest` is limited to paths under `/api` and JSON bodies. It is
meant for endpoints that do not yet have a dedicated MCP tool.
npm package: @penclipai/ui
Description: Prebuilt Paperclip board UI assets.
Latest version: 2026.411.0

# @penclipai/ui

Published static assets for the Paperclip board UI.

## What gets published

The npm package contains the production build under `dist/`. It does not ship the UI source tree or workspace-only dependencies.

## Typical use

Install the package, then serve or copy the built files from `node_modules/@penclipai/ui/dist`.
npm package: @pencroff/ts-algorithms
Description: Typescript algorithms and Data Structures
Author: @Pencroff
Latest version: 0.0.13

# ts-algorithms
Typescript algorithms and Data Structures

[![Build Status](https://travis-ci.org/Pencroff/ts-algorithms.svg?branch=master)](https://travis-ci.org/Pencroff/ts-algorithms)
[![codecov](https://codecov.io/gh/Pencroff/ts-algorithms/branch/master/graph/badge.svg)](https://codecov.io/gh/Pencroff/ts-algorithms)

## Get started

`npm i @pencroff/ts-algorithms --save`

The package doesn't provide any common exports. All required imports should be per item.
For example:

```
import { genericComparator } from '@pencroff/ts-algorithms/dist/primitive/comparator'

const res = genericComparator('A', 'B'); // returns -1, check primitives for details
```

## Algorithms

* Structures
    * [Linked list (generic doubly linked)](https://ts-algorithms.pencroff.com/classes/structure.linkedlist.html)
    * [Queue (FIFO)](https://ts-algorithms.pencroff.com/classes/structure.queue.html)
    * [Stack (LIFO)](https://ts-algorithms.pencroff.com/classes/structure.stack.html)
    * [Dictionary (hash table, hash map)](https://ts-algorithms.pencroff.com/classes/structure.dictionary.html)
    * [Heap (binary min heap)](https://ts-algorithms.pencroff.com/classes/structure.binaryheap.html)
    * [PriorityQueue (based binary heap)](https://ts-algorithms.pencroff.com/classes/structure.priorityqueue.html)
* Search
    * [Linear Search](https://ts-algorithms.pencroff.com/modules/search.html#linearindexof)
    * [Binary Search](https://ts-algorithms.pencroff.com/modules/search.html#binaryindexof)
* Sorting
    * [Quicksort](https://ts-algorithms.pencroff.com/modules/sort.html#qsort)
* Hash functions
    * [fnv1a (32 bit)](https://ts-algorithms.pencroff.com/modules/hash.html#fnv1a32)
    * [murmur2 (32 bit)](https://ts-algorithms.pencroff.com/modules/hash.html#murmur2_32)
    * [murmur3 (32 bit)](https://ts-algorithms.pencroff.com/modules/hash.html#murmur3_32)
    * [Sum32](https://ts-algorithms.pencroff.com/modules/hash.html#sum32)
    

## Theory

Big O notation is used in computer science to describe the performance or complexity of an algorithm.

![Big O chart](https://ts-algorithms.pencroff.com/assets/big-o-chart.svg)
source: www.bigocheatsheet.com

Big O can be used for measuring time complexity or space / memory complexity.

References:

* 📝 [The Big O Notation](https://dev.to/sarah_chima/the-big-o-notation-an-introduction-34f7)
* 📽️ [Big O Notation](https://www.youtube.com/watch?v=v4cd1O4zkGw)
npm package: @pencroff/typeorm-better-sqlite3
Description: better-sqlite3 driver for typeorm
Author: @Pencroff
Latest version: 1.1.3

# typeorm-better-sqlite3

[Github](https://github.com/Pencroff/typeorm-better-sqlite3)

Performant [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) driver for [Typeorm](https://typeorm.io/#/).

It's 10x or even 18x faster for some cases - [link](https://github.com/JoshuaWise/better-sqlite3#how-other-libraries-compare)

## Usage

```
import { Connection, createConnection } from 'typeorm';
import { OrmService } from '@pencroff/typeorm-better-sqlite3';

async function run() {
    const orm = new OrmService();
    const con = await createConnection();
    await orm.useConnection(con);
    const repo = orm.getRepo(SomeModel);
    const result: SomeModel[] = await repo.find({
      where: {
        fieldA: 'abd',
        fieldB: 123,
      },
    })
}

```

for more details please check **[example](https://github.com/Pencroff/typeorm-better-sqlite3/tree/master/example)** folder

## Instalation notes

It requires building tools and Python 2 (should be >=2.6.0 <3.0.0).

Python 2 can be used from folder "C:\Python27\python.exe" (Not required to be in `PATH`)

Actually just run as Administrator (if you have any issue with compiling `better-sqlite3`):

```
npm install --global --production windows-build-tools
```

More details [here](https://github.com/nodejs/node-gyp#on-windows).

Make sure to have `sqlite3` package in your dev dependency. It requires for migrations.

## Known issues

* Import `createConnection` before `OrmService`. Like below:

```
import { createConnection } from 'typeorm';
import { OrmService } from '@pencroff/typeorm-better-sqlite3';
```
npm package: @pendalf/vfc
Description: Vue form components with validation
Latest version: 1.1.5

<p align="center">
  <img src="./example/assets/logo.svg" style="margin-bottom: -20px">
</p>
<h1 align="center">Vue Form Components</h1>
<p align="center">
  <img src="https://img.shields.io/travis/antonreshetov/vue-form-components.svg">
  <img src="https://img.shields.io/bundlephobia/minzip/vfc.svg">
  <img src="https://img.shields.io/github/license/antonreshetov/vue-form-components.svg">
</p>

## Documentation

[https://antonreshetov.github.io/vue-form-components](https://antonreshetov.github.io/vue-form-components/)

## Install

### NPM

Installing with npm is recommended and it works seamlessly with webpack.

```js
npm i vfc
```

### Download

You can download latest version from the Github: Download

## Quick start

### Global

To use in your project, just import vfc and install into Vue.

```js
import Vue from 'vue'
import App from './App.vue'
import VFC from 'vfc'
import 'vfc/dist/vfc.css'

Vue.use(VFC)

new Vue({
  render: h => h(App)
}).$mount('#app')
```

### On demand

```html
<template>
  <vue-input></vue-input>
</template>

<script>
  import 'vfc/dist/vfc.css'
  import { Input } from 'vfc'

  export default {
    components: {
      [Input.name]: Input
    }
  }
</script>
```

Full component list:

```js
import {
  Input,
  Button,
  Checkbox,
  CheckboxGroup,
  Radio,
  Select,
  Option,
  Form,
  FormItem,
  FormBuilder
} from 'vfc'
```

## License

MIT © 2018-present [Anton Reshetov](http://antonreshetov.com)
npm package: @pendant/api-react
Description: > TODO: description
Author: 陈敬杰
Latest version: 0.0.6

# `api-react`

> 快速请求 [CODING OPEN API](https://help.coding.net/openapi)

## Usage

```tsx
import { setConfig, useFetchApi } from '@pendant/api-react';

setConfig({ clientId: '1234565' });

const ProjectListDemo = () => {
  const { response, error } = useFetchApi('DescribeCodingProjects', query);

  if (error || response?.Error) {
    return <>获取数据错误</>
  }

  if (response?.Data?.ProjectList instanceof Array) {
    return response?.Data?.ProjectList.map(project => <div>{project.Name}<div>)
  }

  return <>loading</>;
}

export default ProjectListDemo;
```

## Api

### setConfig

设置 `api-react` 的配置

```ts
{
  clientId: string;
  fetch?: Parameters<typeof fetch>;
}
```

| 参数     | 说明                                                                                                           | 类型                     | 默认值 |
| -------- | -------------------------------------------------------------------------------------------------------------- | ------------------------ | ------ |
| clientId | 客户端 ID                                                                                                      | string                   | -      |
| fetch    | fetch 的默认参数[RequestInfo \| URL, { headers: RequestInit['headers'] }]，在发送请求的时候会合并到 参数里面。 | Parameters<typeof fetch> | -      |

### fetchApi

函数式使用 `fetchApi` ， `hooks` 使用 `useFetchApi` .

```tsx
fetchApi('DescribeCodingProjects', query).then((res) => console.log(res));
const { response, error } = useFetchApi('DescribeCodingProjects', query);
```

| 参数   | 说明              | 类型   | 默认值 |
| ------ | ----------------- | ------ | ------ |
| action | 需要调用的业务 id | string | -      |
| query  | 请求参数          | Object | -      |

### getContext

获取应用的上下文信息

```tsx
const { accessToken, apiUrl } = await getContext();
```
npm package: @pendle/create-ts-lib
Description: This is a small project for generating library for the Pendle team. This package's structure: - `template`: the actual template for our project. - `index.js`: the script for rendering a real folder from template, substituting variables such as project nam
Author: An, Tran Cong Viet
Latest version: 0.0.5

# Pendle Library Generator

This is a small project for generating library for the Pendle team.
This package's structure:
- `template`: the actual template for our project.
- `index.js`: the script for rendering a real folder from template, substituting variables such as project name or author name.

Use this package by running
```shell
npx @pendle/create-ts-lib
```
npm package: @pendle/single-staking
Description: Smart contracts to convert PENDLE to xPENDLE
Author: Pendle Protocol Team
Latest version: 0.0.1

# PENDLE single sided staking

## Introduction

Pendle’s protocol leverages on the base lending layer created by prominent DeFi protocols such as Aave and Compound, which has shown incredible growth and community acceptance. We build on this layer by separating the future cash flows from these lending protocols’ yield tokens and tokenizing it. This allows future yield to be traded without affecting ownership of the underlying
asset.

Ownership of the future cash flows is guaranteed by the smart contract, so there is no need to worry about collateral or counterparty risk, as long as the underlying lending protocol is not compromised.
npm package: @pendo324/get-process-by-name
Description: Returns a list of processes that match a process name
Author: pendo324
Latest version: 1.0.1

[![npm version](https://badge.fury.io/js/%40pendo324%2Fget-process-by-name.svg)](https://badge.fury.io/js/%40pendo324%2Fget-process-by-name)

## Usage

Just require the module

```
const { getProcessByName } = require('get-process-by-name');
```

`await getProcessByName(<executableName>)`:
- executableName (string, required): the name of the executable that you want the info for. Omitting this argument (or supplying an executable name that doesn't have running processes) will return an empty list.

- Returns an Array of processes (i.e. `Promise<process[]>`) where imagename (executable name) equals executableName

`process` Object structure:
```js
{
    imageName: string, // executable name (usually *.exe)
    pid: number, // process id
    sessionName: string,
    sessionNumber: number,
    memUsage: number, // memory consumption, in bytes
    status: string,
    userName: string,
    cpuTime: string, // CPU time in the format HH:MM:SS, where MM and SS are between 0 and 59 and HH is any unsigned number
    windowTitle: string
}
```

## Todo (pull requests welcome!)

- Add Linux support
- Add Mac support
- Add tests
- Add automatic build server
npm package: @pendulum-baas/mcp
Description: MCP Server for natural language querying locally
Author: Pendulum BaaS
Latest version: 1.0.0

# @pendulum-baas/mcp

MCP (Model Context Protocol) server for natural language querying of deployed Pendulum BaaS backends. This tool allows you to interact with your Pendulum backend using natural language queries through compatible AI assistants like Claude Desktop.

![Pendulum MCP Real-Time Monitoring Demo](./mcp_realtime_monitoring_snippet.png)

## Installation

```bash
npm install -g @pendulum-baas/mcp
```

## Usage

### Arguments

- `--url` (required): The URL of your app's Application Load Balancer.
- `--jwt-secret` (required): JWT Secret generated during deployment — can be found in AWS Secrets Manager.

### Run MCP Server Manually

You can start the MCP server with your Pendulum backend credentials locally:

```bash
pendulum-mcp --url <backend-url> --token <auth-token>
```

## Configuration with Claude Desktop
Add the following to your Claude Desktop MCP configuration:
```json
{"mcpServers": {
  "pendulum": {
    "command": "pendulum-mcp",
    "args": [
      "--url", "<your-alb-url>",
      "--jwt-secret", "<your-jwt-secret>"
    ],
    "env": {
      "PATH": "/Users/username/.nvm/versions/node/v22.14.0/bin:/usr/local/bin:/usr/bin:/bin"
    }
  }
}}
```

## Available Tools

The MCP server provides the following tools for interacting with your Pendulum backend:

### `check-health-status`
Get real-time insights into the health and status of both backend services.

### `get-active-users`
Returns the number of users currently connected to your application.

### `infer-schema`
Given a collection, infers and generates JSON that represents the schema of the collection.

### `validate-schema`
Given a collection and an expected schema, identifies any documents in the collection that do not conform to the expected schema. Returns `_id` values for those that do not match.

### `start-realtime-logs`
Monitor and log all realtime events as they are broadcast out to active users for a specified amount of time. Log file is timestamped and written to user's local `/tmp` directory.

### `stop-realtime-logs`
Stop a real-time monitoring session.

### `realtime-logs-status`
Check the status of any active real-time monitoring sessions.

## Features

- **Natural Language Queries**: Ask questions about your backend in plain English
- **Real-time Monitoring**: Get live insights into your backend state
- **Service Health**: Monitor the health and performance of your Pendulum services
- **Schema Inference and Validation**: Have LLMs generate schemas based on your existing data so you can add stricter data validation rules to your frontend code.

## Requirements

- Node.js 18.0.0 or higher
- Valid Pendulum backend with authentication
- Compatible MCP client (like Claude Desktop)

## License

MIT