textile-go
Status
This repository contains the core Textile node and daemon, a command-line client, and a mobile client for building an iOS/Android application.
See textile-mobile for the Textile Photos iOS/Android app.
What is Textile?
Textile provides encrypted, recoverable, schema-based, and cross-application data storage built on IPFS and libp2p. We like to think of it as a decentralized data wallet with built-in protocols for sharing and recovery, or more simply, an open and programmable iCloud.
Please see the Wiki for more.
Install
Download the latest release for your OS.
Usage
~ $ textile --help
Usage:
textile [OPTIONS] <command>
Help Options:
-h, --help Show this help message
Available commands:
add Add file(s) to a thread
address Show wallet address
blocks View thread blocks
cafes Manage cafes
chat Start a thread chat
comments Manage thread comments
daemon Start the daemon
get Get a thread file by ID
ignore Ignore a thread file
init Init the node repo and exit
invites Manage thread invites
keys Show file keys
likes Manage thread likes
ls Paginate thread files
messages Manage thread messages
migrate Migrate the node repo and exit
notifications Manage notifications
peer Show peer ID
ping Ping another peer
profile Manage public profile
sub Subscribe to thread updates
swarm Access IPFS swarm commands
threads Manage threads
version Print version and exit
wallet Manage or create an account wallet
Quick-start
Initialize a new wallet.
$ textile wallet init
This will generate a mnemonic phrase for accessing / recovering derived accounts. You may specify a word count and password as well (run with --help
for usage).
Initialize a peer with an account.
Next, use an account seed from your wallet to initialize a new peer. First time users should just use the first account’s (Account 0) seed, which is printed out by the wallet init
sub-command. The private seed begins with “S”. The public address begins with “P”. Use the accounts
sub-command to access deeper derived wallet accounts.
$ textile init -s <account_seed>
Start the daemon.
$ textile daemon
You can now use the command-line client to interact with your running peer.
Adding Files
Files are tracked by threads. So, let’s start there.
Create a new thread.
$ textile threads add "hello world" --photos
This will create and join a thread backed by the built-in photos schema. Use the --help
flag on any sub-command for more options and info.
Add a file to the thread.
$ textile add <image path> --caption "beautiful"
The thread schema encodes the image at various width and extracts exif data. The resulting files are added to the thread under one directory. You also add an entire directory.
$ textile add <dir path> --caption "more beauty"
Browse files.
The command-line client is not really meant to provide a great UX for browsing account files. However, you can easily paginate through them with ls
.
Note: A file’s ID is just its block (update) ID.
$ textile ls --thread <thread ID>
$ textile comments add "good eye" --block <block ID>
Like a file.
$ textile likes add --block <block ID>
Sharing files / chatting
In order to start sharing or chatting with someone else, you’ll first need an open thread. Open threads allow invites to other peers.
$ textile threads add "dog photos" --photos --open
Again, we used the built-in photos schema, but this time we’ve opened the thread to invites. Invites allow other peers to join threads. There are two types of invites: direct peer-to-peer and external.
- Peer-to-peer invites are encrypted with the invitee's public key.
- External invites are encrypted with a single-use key and are useful for on-boarding new users. Once an external invite and its key are shared, you should considered it public, since any number of peers can use it to join.
Create a direct peer-to-peer thread invite.
$ textile invites create --thread <thread ID> --peer <peer ID>
The receiving peer will be notified of the invite. They can list all pending direct invites.
$ textile invites ls
The result is something like:
[
{
"id": "QmUv8783yptknBHCSSnscWNLZdz5K8uhpHZYaWnPkMxu4i",
"name": "dog photos",
"inviter": "fido",
"date": "2018-12-07T13:02:57-08:00"
}
]
Accept a direct peer-to-peer invite.
$ textile invites accept QmUv8783yptknBHCSSnscWNLZdz5K8uhpHZYaWnPkMxu4i
Create an “external” thread invite.
This is done by simply omitting the --peer
flag with the invites create
command.
$ textile invites create --thread <thread ID>
The result is something like:
{
"invite": "QmcDmpmBr6qB5QGvsUaTZZtwpGpevGgiSEa7C3AJE9EZiU",
"key": "aKrQmYCMiCQvkyjnm4sFhxdZaFH8g9h7EaLxdBGsZCVjsoyMPzQJQUyPrn7G"
}
Your friend can use the resulting address and key to accept the invite and join the thread.
$ textile invites accept QmcDmpmBr6qB5QGvsUaTZZtwpGpevGgiSEa7C3AJE9EZiU --key aKrQmYCMiCQvkyjnm4sFhxdZaFH8g9h7EaLxdBGsZCVjsoyMPzQJQUyPrn7G
At this point, both of you can add and receive files via this thread. You can also exchange plain text messages.
Add a text message to a thread.
$ textile messages add "nice photos" --thread <thread ID>
Start a chat in a thread.
$ textile chat --thread <thread ID>
This will start an interactive chat session with other thread peers.
Building File Schemas
To-do.
Using a Cafe
To-do.
Hosting a Cafe
To-do.
Contributing
Go get the source code.
$ go get github.com/textileio/textile-go
You can ignore the gx
package errors. You'll need two package managers to get setup…
Install the golang package manager, dep
.
$ brew install dep
Install the IPFS package manager, gx
.
$ go get -u github.com/whyrusleeping/gx
$ go get -u github.com/whyrusleeping/gx-go
Install the dependencies managed by dep
and gx
.
$ make setup
Run the tests.
$ make test_compile
Building
There are various things to build…
CLI/daemon
$ make build
iOS Framework
$ go get golang.org/x/mobile/cmd/gomobile
$ gomobile init
$ make ios_framework
Android Framework
$ go get golang.org/x/mobile/cmd/gomobile
$ gomobile init
$ make android_framework
Acknowledgments
While now almost entirely different, this project was jump-started from OpenBazaar. Thanks to @cpacia, @drwasho and the rest of the contributors for their work on openbazaar-go.
And of course, thank you, Protocal Labs, for the incredible FOSS effort and constant inspiration.
License
MIT