Skip to content
/ charm Public
forked from charmbracelet/charm

The Charm Tool and Library 🌟

License

Notifications You must be signed in to change notification settings

DevNack/charm

 
 

Repository files navigation

Charm

A little cloud with a pleased expression followed by the words ‘Charm from Charm’
Latest Release GoDoc Build Status

Charm is a set of tools that makes adding a backend to your terminal-based applications fun and easy. Quickly build modern CLI applications without worrying about user accounts, data storage and encryption.

Charm powers terminal apps like Glow and Skate.

Features

  • Charm KV: an embeddable, encrypted, cloud-synced key-value store built on BadgerDB
  • Charm FS: a Go fs.FS compatible cloud-based user filesystem
  • Charm Crypt: end-to-end encryption for stored data and on-demand encryption for arbitrary data
  • Charm Accounts: invisible user account creation and authentication

There’s also the powerful Charm Client for directly accessing Charm services. Self-hosting a Charm Cloud is as simple as running charm serve.

Charm KV

A powerful, embeddable key-value store built on BadgerDB. Store user data, configuration, create a cache or even store large files as values.

When you use Charm KV your users automatically get cloud backup, multi-machine syncing, end-to-end encryption, and the option to self-host.

import "github.com/charmbracelet/charm/kv"

// Open a database (or create one if it doesn’t exist)
db, err := kv.OpenWithDefaults("my-cute-db")
if err != nil {
    log.Fatal(err)
}
defer db.Close()

// Fetch updates and easily define your own syncing strategy
if err := db.Sync(); err != nil {
    log.Fatal(err)
}

// Save some data
if err := db.Set([]byte("fave-food"), []byte("gherkin")); err != nil {
    log.Fatal(err)
}

// All data is binary
if err := db.Set([]byte("profile-pic"), someJPEG); err != nil {
    log.Fatal(err)
}

Charm KV can also enhance existing BadgerDB implementations. It works with standard Badger transactions and provides top level functions that mirror those in Badger.

For details on Charm KV, see the Charm KV docs.

Charm FS

Each Charm user has a virtual personal filesystem on the Charm server. Charm FS provides a Go fs.FS implementation for the user along with additional write and delete methods. If you're a building a tool that requires file storage, Charm FS will provide it on a networked-basis without friction-filled authentication flows.

import charmfs "github.com/charmbracelet/charm/fs"

// Open the user’s filesystem
cfs, err := charmfs.NewFS()
if err != nil {
    log.Fatal(err)
}

// Save a file
data := bytes.NewBuffer([]byte("some data"))
if err := cfs.WriteFile("./path/to/file", data, fs.FileMode(0644), int64(data.Len())); err != nil {
    log.Fatal(err)
}

// Get a file
f, err := cfs.Open("./path/to/file")
if err != nil {
    log.Fatal(err)
}
defer f.Close()

// Just read whole file in one shot
data, err := cfs.ReadFile("./path/to/file")
if err != nil {
    log.Fatal(err)
}

For more on Charm FS see the Charm FS docs.

Charm Crypt

All data sent to a Charm server is fully encrypted on the client. Charm Crypt provides methods for easily encrypting and decrypting data for a Charm user. All key management and account linking is handled seamlessly by Charm.

For more on Charm Crypt see the Charm Crypt docs.

Charm Accounts

The best part of Charm accounts is that both you and your users don’t need to think about them. Charm authentication is based on SSH keys, so account creation and authentication is built into all Charm tools and is invisible and frictionless.

If a user already has Charm keys, we authenticate with them. If not, we create new ones. Users can also easily link multiple machines to their account, and linked machines will seamlessly gain access to their owners Charm data. Of course, users can revoke machines’ access too.

Backups

You can use charm backup-keys to backup your account keys. Your account can be recovered using charm import-keys charm-keys-backup.tar

Charm Client

The charm binary also includes easy access to a lot of the functionality available in the libraries. This could be useful in scripts, as a standalone utility or when testing functionality.

# Link a machine to your Charm account
charm link

# Set a value
charm kv set weather humid

# Print out a tree of your files
charm fs tree /

# Encrypt something
charm crypt encrypt < secretphoto.jpg > encrypted.jpg.json

# For more info
charm help

Installation

Use a package manager:

# macOS or Linux
brew tap charmbracelet/tap && brew install charmbracelet/tap/charm

# Arch Linux (btw)
pacman -S charm

# Nix
nix-env -iA nixpkgs.charm

Or download a package or binary from the releases page. All major platforms and architectures are supported, including FreeBSD and ARM.

You can also just build and install it yourself:

git clone https://github.com/charmbracelet/charm.git
cd charm
go install

Self-Hosting

Charm libraries point at our Charmbracelet, Inc. servers by default (that’s cloud.charm.sh), however it's very easy for users to host their own Charm instances. The charm binary is a single, statically-linked executable capable of serving an entire Charm instance:

charm serve

Server settings

The Charm server can be configured using environment variables. These are the defaults:

  • CHARM_SERVER_BIND_ADDRESS: Network interface to listen to (default 0.0.0.0)
  • CHARM_SERVER_HOST: Hostname to advertise (default localhost)
  • CHARM_SERVER_SSH_PORT: SSH server port to listen to (default 35353)
  • CHARM_SERVER_HTTP_PORT: HTTP server port to listen to (default 35354)
  • CHARM_SERVER_STATS_PORT: Stats server port to listen to (default 35355)
  • CHARM_SERVER_HEALTH_PORT: Health server port to listen to (default 35356)
  • CHARM_SERVER_DATA_DIR: Server data directory (default ./data)
  • CHARM_SERVER_USE_TLS: Whether to use TLS (default false)
  • CHARM_SERVER_TLS_KEY_FILE: The TLS key file path to use
  • CHARM_SERVER_TLS_CERT_FILE: The TLS cert file path to use
  • CHARM_SERVER_PUBLIC_URL: Server public URL, useful when hosting the Charm server behind a TLS enabled reverse proxy
  • CHARM_SERVER_ENABLE_METRICS: Whether to enable collecting Prometheus metrics (default false) Metrics can be accessed from http://<CHARM_SERVER_HOST>:<CHARM_SERVER_STATS_PORT>/metrics
  • CHARM_SERVER_USER_MAX_STORAGE: Maximum FS storage for a user (default 0) Zero means no limit

To change hosts, users can set CHARM_HOST to the domain or IP of their choosing:

export CHARM_HOST=burrito.example.com

See instructions for Systemd and Docker.

Storage Considerations

The max data you can store on our Charm Cloud servers is 1GB per account. By default, self-hosted servers don't have a data storage limit. Should you want to set a max storage limit on your server, you can do so using CHARM_SERVER_USER_MAX_STORAGE

TLS

To set up TLS, you should set CHARM_SERVER_USE_TLS to true, and specify CHARM_SERVER_HOST, CHARM_SERVER_TLS_KEY_FILE, and CHARM_SERVER_TLS_CERT_FILE file paths.

Projects using Charm

Feedback

We’d love to hear your thoughts on this project. Feel free to drop us a note!

License

MIT


Part of Charm.

the Charm logo

Charm热爱开源 • Charm loves open source

About

The Charm Tool and Library 🌟

Resources

License

Stars

Watchers

Forks

Packages

No packages published

Languages

  • Go 99.9%
  • Dockerfile 0.1%