open-index/open-npm huggingface dataset:
npm package: @fleetfn/sdk
Description: The Fleet SDK for Node.js to query the Fleet API, make deployments, get projects, functions, metrics and etc. It is a lightweight wrapper around the Fleet Rest API.
Author: Fleet FN, Inc
Latest version: 1.0.0-alpha.3

# <img src='https://assets.runfleet.io/cdn/fleet-sdk.svg' height='50' alt='Fleet FN Inc' />

The Fleet SDK for Node.js to query the Fleet API, make deployments, get projects, functions, metrics and etc. It is a lightweight wrapper around the Fleet Rest API.

**This is experimental and not stable! Use it at your own risk.**
npm package: @fleetforgeio/core
Description: FleetForge Core - Domain entities, interfaces, and shared types
Latest version: 0.1.0

# @fleetforge/core

Core domain models, interfaces, and types for the FleetForge IoT Platform.

## Overview

This library provides the foundational domain-driven design (DDD) components for FleetForge, including:

- **Entities**: Rich domain models (Device, Firmware, Deployment, Telemetry, Fleet)
- **Value Objects**: Immutable objects (Location, FirmwareSignature)
- **Enums**: Type-safe enumerations for status and types
- **Interfaces**: Ports for hexagonal architecture (Repositories, Services)

## Installation

```bash
npm install @fleetforge/core
```

## Usage

### Entities

```typescript
import { Device, DeviceStatus, DeviceType } from '@fleetforge/core';

const device = new Device(
  'device-123',
  'fleet-456',
  'Tracker Unit 001',
  DeviceType.TRACKER,
  DeviceStatus.ACTIVE,
  {
    manufacturer: 'Acme Corp',
    model: 'T-1000',
    hardwareVersion: '2.0',
    serialNumber: 'SN123456',
  },
  {
    hasGPS: true,
    hasCamera: false,
    hasCellular: true,
    hasWiFi: false,
    hasBluetooth: true,
    sensors: ['accelerometer', 'gyroscope'],
  },
  '1.0.0',
  new Date(),
);

// Update device status
device.updateStatus(DeviceStatus.UPDATING);

// Check if device is online
if (device.isOnline()) {
  console.log('Device is online');
}
```

### Value Objects

```typescript
import { Location } from '@fleetforge/core';

const location = new Location(
  -23.5505, // latitude
  -46.6333, // longitude
  new Date(),
  10, // altitude
  5, // accuracy
);

// Calculate distance
const distance = location.distanceTo(otherLocation);
console.log(`Distance: ${distance} meters`);
```

### Interfaces (Ports)

```typescript
import { IDeviceRepository, Device } from '@fleetforge/core';

class MongoDeviceRepository implements IDeviceRepository {
  async findById(id: string): Promise<Device | null> {
    // Implementation
  }

  async create(device: Device): Promise<Device> {
    // Implementation
  }

  // ... other methods
}
```

## Architecture

This library follows **Hexagonal Architecture** (Ports and Adapters):

- **Domain Layer**: Pure business logic (entities, value objects)
- **Ports**: Interfaces defining contracts (repositories, services)
- **Adapters**: Implementations in other packages (not in this library)

## Features

- ✅ **Type-Safe**: Full TypeScript support with strict typing
- ✅ **Immutable Value Objects**: Ensures data integrity
- ✅ **Rich Domain Models**: Business logic encapsulated in entities
- ✅ **Validation**: Built-in validation for all domain objects
- ✅ **Testable**: Pure functions and dependency injection
- ✅ **Framework Agnostic**: Can be used with any framework

## License

MIT
npm package: @fleetplannerscollective/cest
Description: Small and light test runner for typescript
Author: Tim Roediger
Latest version: 1.0.8

# Cest

Cest is a small and light test runner for typescript.

I got frustrated with how slow Jest was at running tests, so I made this. It's simple and works.

## Installation

`npm install @fleetplannerscollective/cest`

## Write some tests

```javascript
import cest from '@fleetplannerscollective/cest' // import cest
import { strict as assert } from 'assert' // use the default assertion library from node

const test = cest('my test suite') // Create a suite

test(                // define a test
    'passing test',  // give the test a name
    () => {          // create a funtion to run the test
        assert(true) // if the function doesn't throw an error, the test passes
    }
)

test(
    'failing test', 
    () => {
        assert(false) // if the function throws an error, the test fails
    }
)

test(
    'should throw', 
    () => {
        const t = () => {throw new Error()}
        assert.throws(t, Error) // For tests which should throw an error, use assert.throws, provided by node.js
    }
)

test(
    'async test', 
    async () => { // Cest handles async tests fine
        await new Promise((resolve) => {resolve(true)})
    }
)

test.run() // run all the tests
```

## Run all tests

Use the cli tool:

`cest [path/to/ts/dir]`

Cest will identify all `.test.ts` files in the path, find `.tsconfig` locate the compiled `.js` files and run them.
Cest will also identify all `.test.js` files in the path and run them.

## Run a single test suite without CLI

You can run a sinlge test suite by directly calling the `.js` file
`node mytest.js`

## Run tests programatically

```
import cest from '@fleetplannerscollective/cest'

const result = cest.runner('path to tests')
if (result) {
    // tests passed
} else {
    // tests failed
}
```

## Development

* Clone the repo.
* Install dev dependencies `npm install`.
* Run `npm run build`
* Run `npm run test`

To remove the dist folder for a completely fresh build `npm run clean`.

To incrementally rebuild whilst working `npm run watch`.
npm package: @fleettools/opencode-plugin
Description: FleetTools OpenCode Plugin - AI Agent Coordination System
Author: FleetTools
Latest version: 1.1.3

# FleetTools OpenCode Plugin

Integrates FleetTools CLI functionality into OpenCode.

## Installation

Add this plugin to your OpenCode config:

```json
{
  "plugin": ["@fleettools/opencode-plugin"]
}
```

After restarting OpenCode, the plugin will provide tools and commands for FleetTools management.

## Tools

### 📊 `fleet-status`
Get FleetTools service status and configuration

**Parameters:**
- `format` (optional, enum: text|json, default: text) - Output format

**Examples:**
```bash
# Human-readable status
/fleet-status

# JSON format
/fleet-status --format json
```

### 🚀 `fleet-start`
Start FleetTools services

**Parameters:**
- `services` (optional, array: api,squawk) - Services to start (default: all enabled)

**Examples:**
```bash
# Start specific services
/fleet-start --services api,squawk
```

### 🛑 `fleet-stop`
Stop FleetTools services

**Parameters:**
- `services` (optional, array: api,squawk) - Services to stop (default: all running)
- `force` (optional, boolean) - Force stop without graceful shutdown
- `timeoutMs` (optional, number) - Timeout for graceful shutdown (ms)
- `format` (optional, enum: text|json, default: text) - Output format

**Examples:**
```bash
# Graceful stop specific services
/fleet-stop --services api,squawk

# Force stop
/fleet-stop --force api,squawk --timeout 5000
```

## Commands

The plugin also provides these slash commands for quick access:

- **/fleet-status** - Show FleetTools status
- **/fleet-start** - Start FleetTools services  
- **/fleet-stop** - Stop FleetTools services
- **/fleet-help** - Show FleetTools help and usage

## Requirements

- OpenCode >= 1.0.0
- FleetTools CLI (must be available in PATH)
- Node.js >= 18.0.0

## License

MIT License - see LICENSE file for details.