open-index/open-npm huggingface dataset:
npm package: @keepkey/keepkey-sdk
Description: REST api for intergrating with the KeepKey hardware wallet.
Latest version: 0.2.62


# KeepKey SDK

REST api for intergrating with the KeepKey hardware wallet.

- [KeepKey Website](https://www.keepkey.com/)
- [SDK tutorial](https://medium.com/@highlander_35968/creating-a-dapp-for-the-keepkey-desktop-f61e506f5026)

REST (REpresentational State Transfer) is an architectural style used for designing distributed systems. It is based on a client-server model, where the client makes requests to the server and the server responds with a representation of the requested resource. REST is used to build public APIs that are easy to use and maintain.

Swagger is an open source software framework used to describe and document RESTful APIs. It provides a simple way for developers to describe the operations, parameters and responses of an API. Swagger also provides interactive documentation, client SDK generation, and testing tools.

More info:

REST: https://restfulapi.net/

Swagger: https://swagger.io/

# SDK init

```
export const setupKeepKeySDK = async () => {
    let serviceKey = window.localStorage.getItem('@app/serviceKey')
    let config: any = {
        apiKey: serviceKey,
        pairingInfo: {
            name: 'ShapeShift',
            imageUrl: 'https://assets.coincap.io/assets/icons/fox@2x.png',
            basePath: 'http://localhost:1646/spec/swagger.json',
            url: 'https://private.shapeshift.com',
        },
    }
    let sdk = await KeepKeySdk.create(config)

    if (!serviceKey) {
        window.localStorage.setItem('@app/serviceKey', config.apiKey)
    }
    return sdk
}
```
# SDK usage

## API

get a bitcoin address

```
     let path =
        {
          symbol: 'BTC',
          address_n: [0x80000000 + 44, 0x80000000 + 1, 0x80000000 + 0],
          coin: 'Bitcoin',
          script_type: 'p2pkh',
          showDisplay: false
        }

      let addressBtc = await sdk.system.info.getPublicKey(path)
```

sign a BTC tx

```
      let hdwalletTxDescription = {
        coin: 'Bitcoin',
        inputs:inputsSelected,
        outputs:outputsFinal,
        version: 1,
        locktime: 0,
      }

      //signTx
      let signedTxTransfer = await sdk.utxo.utxoSignTransaction(hdwalletTxDescription)
```
npm package: @keepkey/market-service
Description: ShapeShift market data service
Latest version: 7.1.3

# @shapeshiftoss/market-service

> Getting market data through multiple different APIs

## Usage

```typescript
import { getDefaultMarketService } from '@shapeshiftoss/market-service'

const getAssetData = async () => {
    const assetData = await getDefaultMarketService().getAssetData(network, contractAddress)
}
```

## Hot Reloading

To enable hot reloading, you need to have [WML](https://github.com/wix/wml) and [Watchman](https://facebook.github.io/watchman/docs/install.html) installed.

- Once WML is installed, add link(s) from packages to corresponding node_modules in project, ie:

// TODO: update package name once lib is published
```bash
wml add ./Projects/lib/packages/market-service ./Projects/web/node_modules/@shapeshift/market-service
```

- Check packages are linked correctly by running `wml list`, you should see a response similar to this:
```bash
Links:
enabled (0) /Users/userName/projectFolder/lib/packages/market-service -> /Users/userName/projectFolder/web/node_modules/@shapeshift/market-service
```

- Start `WML`
```bash
wml start
```

Note: If you start `wml` and nothing happens, or you see an error, a common cause is watchman is not watching the linked directory. Try "watching" the directory that was linked

```bash
watchman watch [path-to-package]
```

- In a different terminal window, run the typescript server inside the package.

```bash
yarn dev
```
npm package: @keepkey/proto-tx-builder
Description: Builds and signs new-style protobuf SIGN_MODE_DIRECT Cosmos SDK transactions
Author: ShapeShift DAO
Latest version: 0.9.1

# proto-tx-builder

Constructs and signs protobuf encoded cosmos-sdk

## Getting started

```bash
# Clone submodules
git submodule update --init --recursive
# Install the required dependencies
yarn
```

## Testing

Bug fixes and features should always come with tests, when applicable. Test files should live next to the file they are testing. Before submitting your changes in a pull request, always run the full test suite.

To run the test suite:

```bash
# build all dependent packages
yarn build

# Runs the full test suite
yarn test
```

## TS Proto generation

cosmos-sdk uses [protocol buffers](https://developers.google.com/protocol-buffers) to encode txs and other communication between nodes and clients as well as other nodes. proto-tx-builder leverages the protobuf definitions to generate the TypeScript implementation of the custom protobufs required to interact with a given chain.

-   place .proto files for the cosmos-sdk chain in `./proto` and `./third_party/proto` directories
-   remove existing generated files:
    ```bash
    rm -rf ./proto/generated/*
    ```
-   execute the generation script:
    ```base
    ./gen.sh
    ```
-   commit the generated content along with your changes

## Contributing

Please see the [Contributing Guidelines](CONTRIBUTING.md) document for this repo's specific contributing guidelines.
npm package: @keepkey/swapper
Description: An interface and implementations to trade coins via various protocols
Latest version: 14.2.0

# @shapeshiftoss/swapper

## Getting Started

```sh
yarn add @shapeshiftoss/swapper
```

## Usage

### Swapper CLI
- Copy the `sample.env` to `.env`
```sh
cp sample.env .env
```

- Usage:
```sh
$ swapcli [sellSymbol] [buySymbol] [sellAmount](denominated in sell asset, not wei)
```
ie:
```sh
$ swapcli ETH USDC 0.001
```

### Setup

```ts
import { SwapperManager, SwapperType, ZrxSwapper } from '@shapeshiftoss/swapper'

// in code
const manager = new SwapperManager<MyCustomSwapperTypes>()

// Add a swapper to the manager, you can add your own if it follows the `Swapper` API spec
manager
  .addSwapper(new ZrxSwapper())
  .addSwapper(new ThorchainSwapper())

// Get a swapper from the manager
const swapper = manager.getSwapper(SwapperType.Zrx)

// Remove a swapper from the manager
manager.removeSwapper(SwapperType.ZrxEthereum)
```

### Working with the manager

```ts
// Get best quote and swapper for a trading pair
const { swapperType, quote } = await manager.getBestQuote(...args)

// Get the swapper and do stuff
const swapper = manager.getSwapper(swapperType)
```

### Working with a specific swapper

```ts
// Get a list of supported assets/trading pairs
const assets = await swapper.getSupportedAssets()

// Get a quote from a swapper
const quote = await swapper.getQuote(...args)

// Execute a Trade
const txToSign = await swapper.buildTransaction(...args)

// broadcast your TX
const tx = await swapper.execute(signedTx)
// or
const tx = await adapter.broadcastTransaction(...args)
```
npm package: @keepkey/unchained-client
Description: Provides a TypeScript axios client to interact with all supported unchained APIs.
Latest version: 10.3.0

# @shapeshiftoss/unchained-client

Provides a TypeScript axios client to interact with all supported unchained APIs.

## Installing

Using npm:

```sh
npm install @shapeshiftoss/unchained-client
```

Using yarn:

```sh
yarn add @shapeshiftoss/unchained-client
```

## Resources

- [CAIP-2](https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md) naming conventions used for `chainId`
- [CAIP-19](https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-19.md) naming conventions used for `assetId`

## Usage

```typescript
import * as unchained from '@shapeshiftoss/unchained-client'

const address = 'cosmos1t5u0jfg3ljsjrh2m9e47d4ny2hea7eehxrzdgd'

// configuration for the api client
const config = new unchained.cosmos.Configuration({ basePath: 'https://dev-api.cosmos.shapeshift.com' })

// create new instance of the api client
const apiClient = new unchained.cosmos.V1Api(config)

// create new instance of the ws client
const wsClient = new unchained.ws.Client<unchained.cosmos.Tx>('wss://dev-api.cosmos.shapeshift.com')

// create new instance of the transaction parser
// chainId is in the format of [Caip2](https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md)
const parser = new unchained.cosmos.TransactionParser({ chainId: 'cosmos:cosmoshub-4' })

// example api client request
const { data } = await apiClient.getBalance({ pubkey: address })

// example websocket subscription for new transaction and transaction parsing
await this.providers.ws.subscribeTxs(
  'test',
  { topic: 'txs', addresses: [address] },
  async (msg) => {
        const tx = await parser.parse(msg.data, msg.address)
  },
  (err) => console.warn(err)
)
```
npm package: @keeplifestories/prettier-config
Description: Honeycomb Prettier Config
Author: Philihp Busby
Latest version: 1.0.0

# prettier-config

Encourage consistency by having a shared config.

## Usage

**Install**:

```bash
$ yarn add --dev @keeplifestories/prettier-config
```

**Edit `package.json`**:

```jsonc
{
  "name": "honeycomb-repo",
  "version": "4.2.0",
  // ...
  "prettier": "@keeplifestories/prettier-config"
}
```

Based on https://github.com/azz/prettier-config
npm package: @keeply-link/mcp
Description: Keeply MCP server — manage your bookmarks from any AI assistant
Latest version: 1.0.1

# @keeply-link/mcp

MCP server for [Keeply](https://keeply.tools) — manage your bookmarks from any AI assistant.

## What it does

Connects your Keeply bookmark library to MCP-compatible AI assistants (Claude, Cursor, Windsurf, and others). Search, save, and organise bookmarks without leaving your conversation.

## Installation

### Claude Code

```bash
claude mcp add keeply -e KEEPLY_API_KEY="your-api-key" -- npx -y @keeply-link/mcp
```

### Claude Desktop / Cursor / Windsurf

Add to your MCP config:

```json
{
  "mcpServers": {
    "keeply": {
      "command": "npx",
      "args": ["-y", "@keeply-link/mcp"],
      "env": {
        "KEEPLY_API_KEY": "your-api-key"
      }
    }
  }
}
```

### OpenCode

Add to your `opencode.json`:

```json
{
  "mcp": {
    "keeply": {
      "type": "local",
      "command": ["npx", "-y", "@keeply-link/mcp"],
      "environment": {
        "KEEPLY_API_KEY": "your-api-key"
      }
    }
  }
}
```

## Setup

1. Get an API key at [app.keeply.tools](https://app.keeply.tools) under **Settings → API Keys**
2. Grant the following scopes: `read_bookmarks`, `create_bookmark`, `update_bookmark`, `delete_bookmark`, `read_folders`, `read_tags`, `search_bookmarks`
3. Add the server to your AI client using the config above

## Available tools

| Tool | Description |
|---|---|
| `search_bookmarks` | Full-text search across your library |
| `list_bookmarks` | List bookmarks, optionally filtered by folder, tag, or archived status |
| `get_bookmark` | Fetch a single bookmark by ID |
| `add_bookmark` | Save a new bookmark |
| `update_bookmark` | Update title, note, tags, folder, or archived status |
| `delete_bookmark` | Soft-delete a bookmark (recoverable from the app) |
| `list_folders` | List all folders with bookmark counts |
| `list_tags` | List all tags with bookmark counts |

## Environment variables

| Variable | Required | Description |
|---|---|---|
| `KEEPLY_API_KEY` | Yes | Your Keeply API key |

## Documentation

Full documentation at [dev.keeply.tools/docs/mcp](https://dev.keeply.tools/docs/mcp).

## License

MIT
npm package: @keeprealz/template-cover-renderer
Description: Shared cover template renderer for jobcard systems
Author: Chris.Zhang
Latest version: 1.0.7

# @keeprealz/template-cover-renderer
工卡封面通用渲染包

## 安装
npm install @keeprealz/template-cover-renderer

## 使用
```js
<template>
    <!-- 预览模式：使用 CoverRenderer 渲染当前 schema -->
    <CoverRenderer
        :schema="previewSchema"
        :paperWidthPx="paperWidthPx"
        :cellHeightPx="cellHeightPx"
        :data="previewData"
        root-class="editor-preview-root"
        item-class="editor-preview-item"
    />
</template>

<script lang="ts" setup>
import { CoverRenderer, type CoverSchema } from '@keeprealz/template-cover-renderer';
</script>
npm package: @keeps-learn/nexus-proto
Description: Shared Protocol Buffer definitions for Nexus microservices
Author: Keeps
Latest version: 0.12.0

# Nexus Proto

Shared Protocol Buffer definitions for Nexus microservices.

## Why "Nexus"?

The name **Nexus** was chosen to represent the **central connection** between microservices. In many languages, "nexus" refers to a point of intersection or link, which is exactly what this project provides: an efficient hub for communication between distributed services built in different technologies. The idea is to create a convergence point that makes it easier to integrate systems, ensuring consistent and scalable communication, no matter the language or framework used. **Nexus** is the solution that connects and unites services in a simple and effective way.

## Features

- **Centralized Protocol Definitions**: All communication contracts are defined in a shared repository of `.proto` files.
- **Pre-Generated Python Stubs**: Python stubs (`*_pb2.py` and `*_pb2_grpc.py`) are automatically generated and included in the package, eliminating the need for consumers to generate them.
- **Multi-Language Support**: Easily integrate microservices written in different programming languages (e.g., Python, Node.js, Java, etc.).
- **Scalable Communication**: Easily extend the system as new microservices are added to the architecture.
- **gRPC-powered**: Leveraging gRPC for high-performance communication with built-in support for multiple programming languages.
- **Industry Standard**: Follows best practices from projects like `googleapis-common-protos`, ensuring consistency and reliability.

## Installation

### Node.js / npm

```bash
npm install @keeps-learn/nexus-proto
```

📦 **npm Package**: https://www.npmjs.com/package/@keeps-learn/nexus-proto

### Python / pip

```bash
pip install keeps-learn-nexus-proto
```

📦 **PyPI Package**: https://pypi.org/project/keeps-learn-nexus-proto/

## Quick Start - Python

### Using Pre-Generated Stubs (Recommended)

```python
# Import stubs directly - no compilation needed!
from nexus_proto.generated.myaccount import users_pb2, users_pb2_grpc
from nexus_proto.generated.konquest import mission_pb2, mission_pb2_grpc

# Use message types
user = users_pb2.User(id="123", name="John Doe")

# Use service stubs with gRPC
import grpc
channel = grpc.aio.secure_channel('localhost:50051', grpc.ssl_channel_credentials())
stub = users_pb2_grpc.UserServiceStub(channel)
```

See [USAGE.md](./USAGE.md) for more detailed examples and options.

## Publishing

1. Update version in `package.json`, `setup.py`, and `pyproject.toml`
2. Commit: `git commit -m "Bump version to X.Y.Z"`
3. Tag: `git tag vX.Y.Z`
4. Push: `git push origin vX.Y.Z`

GitHub Actions publishes automatically to both **npmjs.com** and **pypi.org**

See [PUBLISH.md](./PUBLISH.md) for detailed publishing instructions.
npm package: @keepsolutions/mllp-node
Description: MLLP (HL7) implementation in Node.js
Author: Dmitry Kachaev
Latest version: 1.0.1

Forked from https://github.com/amida-tech/mllp because it needed to get issues fixed, namely:

* Create a clone of the input data array prior to swapping elements

mllp
====

[![NPM](https://nodei.co/npm/mllp-node.png)](https://nodei.co/npm/mllp-node/)

[![Build Status](https://travis-ci.org/amida-tech/mllp.svg)](https://travis-ci.org/amida-tech/mllp)
[![Coverage Status](https://coveralls.io/repos/amida-tech/mllp/badge.png)](https://coveralls.io/r/amida-tech/mllp)

HL7's MLLP (Minimum Lower Layer Protocol) server implementation in Node.js.


Listen on predefined port for HL7 messages in format:

```
<VT>[HL7 Message]<FS><CR>
```

* [HL7 MLP minimul layer protocol defined](http://www.hl7standards.com/blog/2007/05/02/hl7-mlp-minimum-layer-protocol-defined/)
* [ACK message](http://www.hl7standards.com/blog/2007/02/01/ack-message-original-mode-acknowledgement/)


## Quick up and running guide

### Prerequisites

- Node.js (v0.10+) and NPM
- Grunt.js

```
# you need Node.js and Grunt.js installed

# install dependencies and build
npm install
grunt
```

## Usage

See `example.js`:

```javascript
var mllp = require('mllp-node');

var server = new mllp.MLLPServer('127.0.0.1', 1234);

// Subscribe to inbound messages
server.on('hl7', function (data){
    console.log('received payload:', data);
});

// Send outbound messages
server.send('127.0.0.1', 4321, 'outbound-hl7-message', function (err, ackData) {
    // async callback code here
});
```

## Contributing

Contributors are welcome. See issues on [GitHub issues](https://github.com/amida-tech/mllp/issues)

## Release Notes

See release notes [here] (./RELEASENOTES.md)

## License

Licensed under [Apache 2.0](./LICENSE)
npm package: @keepsolutions/primeng
Description: [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Join the chat at https://gitter.im/primefaces/primeng](https://badges.gitter.im/primefaces/primeng.svg)](https://gitter.im/primefaces/primeng?ut
Author: goncalo.ferreira
Latest version: 8.0.3-SNAPSHOT-KEEPS


[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Join the chat at https://gitter.im/primefaces/primeng](https://badges.gitter.im/primefaces/primeng.svg)](https://gitter.im/primefaces/primeng?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![npm version](https://badge.fury.io/js/primeng.svg)](https://badge.fury.io/js/primeng)
[![Build Status](https://travis-ci.org/primefaces/primeng.svg?branch=master)](https://travis-ci.org/primefaces/primeng)

# PrimeNG

UI Components for Angular

See [PrimeNG homepage](http://www.primefaces.org/primeng) for live showcase and documentation.

[![PrimeNG Logo](https://www.primefaces.org/wp-content/uploads/2018/05/primeng-sidebar.svg "PrimeNG")](https://www.primefaces.org/primeng)

PrimeNG is a collection of rich UI components for Angular. All widgets are open source and free to use under MIT License. PrimeNG is developed by [PrimeTek Informatics](http://www.primetek.com.tr), a vendor with years of expertise in developing open source UI solutions. For project news and updates, please follow us on [twitter](https://twitter.com/prime_ng) and visit our [blog](https://www.primefaces.org/blog).

 - **80+ Components:** The most complete set of native widgets featuring 80+
   easy to use components for all your UI requirements.

- **Open Source:** Hosted at GitHub, all widgets are open source and free to use under MIT license. Feel the power of open source.

- **Productivity:** Allocate your valuable time on business logic rather than dealing with the complex user interface requirements.

- **Themes:** Don't get tied up in just one look&feel. Choose from a variety of options including material and flat design.

- **Templates:** Professionally designed highly customizable native Angular CLI application templates to get started in no time.

- **Mobile:** Enhanced mobile user experience with touch optimized responsive design elements.

---

#### Download

PrimeNG is available at NPM, if you have an existing application run the following command to download it to your project.

```
npm install primeng --save
npm install primeicons --save
```

#### Angular CLI Integration

Add PrimeNG and PrimeIcons as a dependencies.

```
"dependencies": {
  //...
  "primeng": "^7.0.0",
  "primeicons": "^1.0.0"
},
```

Configure required styles at the styles section, example below uses the Nova Light theme.

```
"styles": [
  "node_modules/primeng/resources/themes/nova-light/theme.css",
  "node_modules/primeng/resources/primeng.min.css",
  "node_modules/primeicons/primeicons.css",
  //...
],
```

That is all, you may now import PrimeNG components, for a working example visit the [PrimeNG CLI QuickStart sample](https://github.com/primefaces/primeng-quickstart-cli) at GitHub.
npm package: @keepyukap/ky-cli-ie8
Description: Devtools for ky-cli-ie8 component
Author: yukap
Latest version: 0.1.7

# ky-cli-ie8

ky-cli-ie8 组件构建工具

# Install

`$ npm i @keepyukap/ky-cli-ie8 -g`

# Usage

* `ky-ie8 init` 初始化[组件模板](https://github.com/keep-yukap/rc-tpl-ie8)
* `ky-ie8 server` 启动本地开发服务器
* `ky-ie8 build` 打包模块
npm package: @keepzen/mutex.js
Description: mutext lock for JS
Author: Keep Zen
Latest version: 0.2.3

![npm](https://img.shields.io/npm/v/@keepzen/mutex.js)
![npm](https://img.shields.io/npm/dm/@keepzen/mutex.js)
![npm](https://img.shields.io/npm/dt/@keepzen/mutex.js)
# The origin
We are told: Js is a single process single thread program frame, so programing
with Js we do not need mutex. But it is not true.

Js run in a single process single thread context, that is true, but not the
frame. Js run in a host context, such as a browser or a node.js process.
The host is multi threads, and some even are multi processes.
We say Js is a single thread, it just mean Js parser run in a thread of the
host processes.

When Js have some asynchronous codes, it mean there are some IPC
between Js parser thread and other host threads/processes.

So if there are some asynchronous codes, maybe mutex are required.

# API
## `mutex.lock()`

`lock()` return a `Promsie<Symbol>`, the symbol is the `key` use in `unlock(key)`.

Mutex like a lock and nobody can unlock the locked lock if do not have a `key`, at least for `@keepzen/mutex.js` this is always true.

Let's just look at code:

```js
cosnt {Mutex}= require('@keepzen/mutex.js');
const m = new Mutex();

async function step(index,ms) {
  const key=await m.lock();// first lock the mutex
  setTimeout(
    ()=>{
      console.log(`index:${index}`);
      m.unlock(key);// when the work is done unlock with the `key`.
    },
    ms
  );
  //Warning: when program run in there,
  //the work is not done, so there is not
  //the place to unlock the mutex.
}
for(let i=0;i<1000;++i){
  let ms = Math.floor(Math.random()*1000);
  step(i,ms);
}
```

## `mutex.try_lock()`

Return a symbol or null.

For a locked `mutex`, if you lock it again, you code will be blocked.
Sometime maybe you just want to have a try but do not want be blocked if fail,
`mutext.try_lock()` is for this.

`try_lock` return a symbol as the key if success. After you done your work, you should unlock the `mutex` with this key, such as `mutext.unlock(key)`.

If `try_lock` return `null` implicit the mutex have be locked by other.

## `unlock(key)`
After you done your work, you must unlock the `mutex` with the `key` which get from the `lock` or `try_lock`.

## `sync()`

`sync` just like Java keyword `synchronized`, you can use it as fellow:
```js
cosnt {
  sync:synchronized
}= require('@keepzen/mutex.js');

//In future you can use `synchronized` as decorate
//@synconized
function step(index,ms){
  setTimeout(()=>{
    console.log(`index:${index}`);
  },ms);
}
const syncStep = synchronized(step);
for(let i=0;i<1000;++i){
  let ms = Math.floor(Math.random()*1000);
  syncStep(i,ms);
}
```
npm package: @keepzen/orm-for-sqlite3
Description: ORM for Learn
Author: Keep in Zen
Latest version: 0.1.0

# What is this package?

I use this package to learn ORM. So I create this one, it is a mini ORM.
You can use this to operate sqlite tables.

# How to use?
1. first install it
  
   Use npm:
  
   ```sh
   npm i @keepzen/orm-for-sqlite3
   ```

   Use yarn
   ```sh
   yarn add @keepzen/orm-for-sqlite3
   ```
2. Create your creat table sql script
3. Create sqlite db file and Module class.
   ```sh
   npx orm-sqlite3-cli db-path/db-name the-dir-you-want-module-to-keep the-sql-script-path
   ```
4. Use the generate Code
   ```js
   const Customer = require('./Customer.table.js');
   let a = Customer({Name:"Bob"});
   async ()=>{
      await a.add();//Insert customer whith Name -- bob
      a.Name = "Tom";
      await a.update();//update
      await a.remove(); //delete
      await Customer.find({select:["ID","Name"],where:"ID != 0",orderBY:["ID"]});//[Customer] 
   }
   ```
npm package: @keeroklab/cli
Description: CLI wrapper for Keerok Lab — live Claude Code supervision
Author: Keerok
Latest version: 0.6.0

# @keeroklab/cli

CLI wrapper for **Keerok Lab** — live Claude Code supervision for training sessions.

Students connect to a supervised session where the instructor can monitor terminals in real-time, send messages, and manage API budgets.

## Quick Start

Your instructor will provide the `<token>` via email or the session page.

### macOS / Linux (no install needed)

```bash
curl -fsSL https://keerok.tech/lab/install.sh | bash -s -- <TOKEN>
```

This will automatically download Node.js if it's not installed on your machine.

### Windows (PowerShell)

```powershell
irm https://keerok.tech/lab/install.ps1 -OutFile keerok.ps1; .\keerok.ps1 <TOKEN>
```

### If you already have Node.js

```bash
npx @keeroklab/cli connect <token> --server https://keerok.tech
```

## Requirements

- A terminal (macOS Terminal, iTerm2, Windows Terminal, etc.)
- Node.js 18+ is downloaded automatically if not present

## What happens when you connect

1. Your token is validated against the server
2. A secure WebSocket connection is established
3. `claude` (Claude Code CLI) is launched in your terminal
4. Your terminal output is streamed to the instructor's dashboard (read-only)

## Options

```
Usage: keerok-lab connect <token> [options]

Arguments:
  token                 Connection token provided by the instructor

Options:
  -s, --server <url>    Server URL (default: "https://keerok.tech")
  -c, --command <cmd>   Command to run (default: "claude")
  -h, --help            Display help
```

## Security

- Your API key is **encrypted (AES-256/Fernet)** and never stored in plain text
- The key is only active during the session and **revoked automatically** when it ends
- The instructor sees your terminal in **read-only** mode (no write access)
- No personal data is kept after the session ends

## How It Works

```
Student terminal                Keerok Server              Instructor dashboard
     │                              │                              │
     ├── validate token ──────────► │                              │
     │◄── session config ─────────  │                              │
     │                              │                              │
     ├══ WebSocket ═══════════════► │ ◄═══════════════ WebSocket ══┤
     │                              │                              │
     │   terminal output ─────────► │ ──── terminal stream ──────► │
     │                              │                              │
     │◄── instructor message ────── │ ◄── send message ───────────┤
     │◄── budget warning ────────── │                              │
     │◄── session ended ─────────── │ ◄── end session ────────────┤
```

## License

MIT
npm package: @keerthivasanprabakaran/r-components
Description: A reusable component library for React
Author: Keerthi Vasan Prabakaran
Latest version: 1.0.21

# React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

## Expanding the ESLint configuration

If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:

- Configure the top-level `parserOptions` property like this:

```js
export default {
  // other rules...
  parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module',
    project: ['./tsconfig.json', './tsconfig.node.json'],
    tsconfigRootDir: __dirname,
  },
}
```

- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list
npm package: @keerthjm/claude-memory
Description: Persistent memory for Claude Code — automatically saves and restores project context across sessions
Author: keerthjm
Latest version: 1.0.1

# claude-memory

Persistent memory for Claude Code. Automatically saves every session and
restores context when you return to a project.

## Install
```bash
npm install -g claudemem
```

Requires [Claude Code](https://www.npmjs.com/package/@anthropic-ai/claude-code) to be installed first.

## Usage

Just use `claude` as normal. Memory works automatically.
```bash
cd my-project
claude
# claude-memory: context loaded for "my-project"
# ... your session runs ...
# claude-memory: 4 messages saved
```

First time in a project, a memory file is created. Every session after
that, context is loaded before Claude starts and saved after it ends.

## Commands
```bash
cmem list              # all projects with memory
cmem show              # full memory for current project
cmem show --context    # context section only
cmem show --log        # session log only
cmem clear             # clear context (keep log)
cmem clear --log       # clear log (keep context)
cmem clear --all       # clear everything
cmem delete            # delete memory for this project
cmem delete --all      # delete all memories
cmem config            # change settings
cmem open              # open memory file in editor
```

## How it works

- Memory is stored in `~/.claude-memory/projects/` — never in your repo
- Each project gets one `memory.md` file with a context section and session log
- Context is injected via `CLAUDE.md` before each session and cleaned up after
- Session content is read from Claude Code's own session files

## Uninstall
```bash
npm uninstall -g claude-memory
```

Your memories stay at `~/.claude-memory/projects` until you delete them.