open-index/open-npm huggingface dataset:
npm package: @gatewayapps/drift
Description: Tooling for creating and migrating relational databases
Author: Gateway Apps, LLC
Latest version: 1.0.0

# Drift
Drift is a development tool for building and publishing relational databases. With Drift, you can define you data structure and logic, migrate your data structure as it changes over time, and publish changes to multiple database providers. Drift leverages [Sequelize](http://docs.sequelizejs.com) v5 to provide support for publishing to multiple database providers.

## Table of Contents
- [Supported Databases](#supported-databases)
- [Installation](#installation)
- [Documentation](#documentation)

## Supported Databases
- Microsoft SQL Server
- Postgres
- MySQL (Coming Soon!!!)
- SQLite (Coming Soon!!!)

## Installation

```bash
$ npm install --save-dev @gatewayapps/drift

# And one (or more) of the following
$ npm install --save tedious # Microsoft SQL Server
$ npm install --save pg pg-hstore # Postgres
```

### Typescript
Type definitions for typescript are included with the package so not addition @types install is required.

## Documentation

- [Quick Start for Microsoft SQL Server](/docs/quick-start/mssql.md)
- [Quick Start for PostgreSQL](/docs/quick-start/postgres.md)
- [Guides](/docs/index.md)
npm package: @gatewayjs/cli
Description: plugin description
Author: cevio
Latest version: 1.0.0

# @gatewayjs/cli

gateway.js的命令行工具

## Install

```bash
$ npm i -g @evio/cli # 如果已安装，请忽略
$ cli install @gatewayjs/cli
$ npm i -g pm2
```

## Interface

```bash
Usage: cli [options] [command]

Options:
  -v, --version                     output the version number
  -h, --help                        output usage information

Commands:
  gw:dev [options]                  GateWay.js development mode
  gw:start [options]                GateWay.js production mode
  gw:restart                        GateWay.js production restart mode
  gw:stop                           GateWay.js production stop mode
  gw [options] <path>               create a new gw file by type
  gw:new [options] [project]        create a new gw project or plugin
  gw:setup [options] <plugins...>   setup plugins into project
```

## Add files

```bash
Usage: gw [options] <path>

create a new gw file by type

Options:
  -c, --controller  create a new `Controller` file
  -m, --middleware  create a new `Middleware` file
  -s, --service     create a new `Service` file
  -t, --decorate    create a new `Decorate` file
  -o, --micro       create a new `Micro` file
  -w, --websocket   create a new `Websocket` file
  -h, --help        output usage information
```

## Custom plugin configs

请在项目根目录下添加`gateway.config.json`文件用来配置默认选项。

## Add custom commander

请在项目根目录下添加`commander.js`来自定义功能。
npm package: @gatewayjs/gateway
Description: Microservice architecture of process gateway, referred to as `MAPG`. It can drive services to dynamically create ancillary process services, manage the whole life cycle of the process tree, provide a complete micro-service call chain, support `HTTP` `TCP`
Latest version: 1.0.27

# Microservice Architecture of Process Gateway

进程网关的微服务架构，简称 `MAPG`。它可以驱使服务动态创建辅助进程服务，同时管理整个进程树的整套生命周期，提供完整的微服务调用链，支持`HTTP` `TCP` `IPC` 以及 `WEBSOCKET`。

Microservice architecture of process gateway, referred to as `MAPG`. It can drive services to dynamically create ancillary process services, manage the whole life cycle of the process tree, provide a complete micro-service call chain, support `HTTP` `TCP` `IPC` and `WEBSOCKET`.

## Usage

```bash
$ npm i -g @evio/cli
$ cli install @gatewayjs/cli
$ cli gw:new
$ cd <project>
$ npm run dev
# --------------------------
$ npm run start
$ npm run restart
$ npm run stop
```

## License

[MIT](http://opensource.org/licenses/MIT)

Copyright (c) 2018-present, yunjie (Evio) shen
npm package: @gatewayjs/mysql
Description: MySQL plug-in for gateway.js
Author: evio
Latest version: 1.0.2

# @gatewayjs/mysql

MySQL plug-in for gateway.js

## Install

```bash
cli gw:setup @gatewayjs/mysql
```

## Usage

```javascript
const mysql = ctx.mysql.get('test');
await mysql.begin();
await mysql.query(sql, ...params);
await mysql.insert(table, data);
await mysql.update(table, data, where, ...wheres);
await mysql.delete(table, where, ...wheres);
```
npm package: @gatewaypayment137/client-test1
Description: > Made with create-react-library
Author: GatewayPayment137
Latest version: 1.0.4

# react-ui-class-lib

> Made with create-react-library

[![NPM](https://img.shields.io/npm/v/react-ui-class-lib.svg)](https://www.npmjs.com/package/react-ui-class-lib) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save react-ui-class-lib
```

## Usage

```tsx
import React, { Component } from 'react'

import MyComponent from 'react-ui-class-lib'
import 'react-ui-class-lib/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License
npm package: @gatewaystack/acp-governance
Description: Agentic Control Plane governance for OpenClaw — identity, audit, and policy enforcement for every tool call via ACP
Author: David Crowe
Latest version: 0.1.1

# Agentic Control Plane — OpenClaw Plugin

Identity, governance, and audit for every OpenClaw tool call.

When active, every tool call your OpenClaw agent makes — `read`, `write`, `exec`, `web_search`, and all custom tools — is logged to your ACP workspace. Set policies to control what's allowed. Get full compliance visibility across your team.

ACP doesn't replace your tools or change how you use OpenClaw. It's the governance layer that sits transparently in front of everything.

## One-command install

```bash
curl -sf https://agenticcontrolplane.com/install-openclaw.sh | bash
```

This installs the plugin, opens your browser to sign up / log in, provisions your workspace, and activates the governance hook. You'll land on your audit log dashboard — done.

Or install manually:

```bash
openclaw plugins install @gatewaystack/acp-governance
```

## How it works

The plugin registers a `before_tool_call` hook that fires before every tool execution:

1. Hook sends tool name + input to ACP's governance API
2. ACP evaluates policies (agent tier, tool rules, rate limits, content scanning)
3. Returns `allow` or `deny`
4. All calls are logged to your workspace's audit trail

The hook **fails open** on network errors — ACP outages never break your agent.

## What you get

- **Audit logs** — every tool call with identity, arguments, timestamps, decisions
- **Policy enforcement** — allow/deny by agent tier, tool name, argument patterns
- **Rate limits & budgets** — cap tool calls per minute, per month, or by cost
- **Content scanning** — detect PII in tool inputs, optionally block or redact
- **Team management** — multiple members, roles, workspace-level controls

## Dashboard

After setup, your dashboard is at:

- **Activity**: `https://cloud.agenticcontrolplane.com/activity`
- **Policies**: `https://cloud.agenticcontrolplane.com/policies`
- **Team**: `https://cloud.agenticcontrolplane.com/team`

## Agent tier mapping

OpenClaw agent IDs map to ACP governance tiers:

| Agent ID | ACP Tier | Default policy |
|---|---|---|
| `main` | Interactive | Permissive — primary user agent |
| Named agents (e.g. `ops`, `dev`) | Subagent | Moderate — spawned for tasks |

## Pause / disable

```bash
# Pause governance (keep credentials)
mv ~/.acp/credentials ~/.acp/credentials.paused

# Resume
mv ~/.acp/credentials.paused ~/.acp/credentials

# Fully remove
rm -rf ~/.acp
openclaw plugins uninstall acp-governance
```

## Support

- Site: https://agenticcontrolplane.com
- Issues: https://github.com/davidcrowe/openclaw-acp-plugin/issues
npm package: @gatewaystack/proxyabl
Description: **Execution control & identity-aware routing for tools and models.**
Latest version: 0.0.11

# @gatewaystack/proxyabl

**Execution control & identity-aware routing for tools and models.**

`@gatewaystack/proxyabl` is the layer that turns your gateway into a **tool / MCP / Apps SDK** hub:

- Serves PRM / OIDC metadata required by MCP & OAuth 2.1.
- Enforces **scope-to-tool** mappings (`TOOL_SCOPES_JSON`).
- Proxies JSON-RPC/tool calls to downstream services.
- Injects **verified identity** into headers/query for your backends.

This is where “who can call which tool/model” becomes an actual routing decision.

---

## Install

```bash
npm install @gatewaystack/proxyabl
# or
pnpm add @gatewaystack/proxyabl
```

## API
`configFromEnv(env)`
Reads environment variables into a typed config object used by the router.

```ts
interface ProxyablConfig {
  // Roughly:
  // - upstream base URLs, per tool/model
  // - PRM metadata (issuer, audience, token endpoint)
  // - tool scope mappings
  // - header injection rules, etc.
}

declare function configFromEnv(
  env: NodeJS.ProcessEnv
): ProxyablConfig;
Expected envs (high-level):
```

- TOOL_SCOPE_ALLOWLIST_JSON / TOOL_SCOPES_JSON – tool → scopes mapping.

- Upstream URLs for tools/models (e.g. TOOL_FOO_BASE_URL).

- OAuth / OIDC metadata for PRM endpoints.

`createProxyablRouter(config)`
Creates an Express router that wires:

- PRM/OIDC well-known endpoints.

- Tool/middleware entrypoints (e.g. /tools/*, /proxy).

- Auth0 integration endpoints (e.g. DCR, log streaming) where relevant.

```ts
import type { RequestHandler } from "express";

declare function createProxyablRouter(
  config: ProxyablConfig
): RequestHandler;
```

## Example
From the reference gateway server:

```ts
import rateLimit from "express-rate-limit";
import {
  createProxyablRouter,
  configFromEnv as proxyablConfigFromEnv,
} from "@gatewaystack/proxyabl";
import { identifiabl } from "@gatewaystack/identifiabl";

const identifiablMiddleware = identifiabl({ /* ... */ });
const proxyablConfig = proxyablConfigFromEnv(process.env);

// Slightly more generous limiter for /tools
const toolsRateLimiter = rateLimit({
  windowMs: +(process.env.RATE_LIMIT_WINDOW_MS ?? 60_000),
  max: +(process.env.RATE_LIMIT_MAX ?? 10) * 10,
  standardHeaders: true,
  legacyHeaders: false,
});

// /tools pipeline:
//   RequestContext (mounted globally)
//   → toolsRateLimiter
//   → identifiabl (JWT → ctx.identity)
//   → proxyabl router (scopes + routing)
app.use(
  "/tools",
  toolsRateLimiter,
  identifiablMiddleware,
  createProxyablRouter(proxyablConfig) as unknown as RequestHandler
);
```

Downstream services can then rely on headers like:

- `X-User-Id`

- `X-Org-Id`

- `X-User-Scopes`

to implement domain-specific policy without ever touching JWTs directly.