Page MenuHomeMusing Studio
Files F10668893

No OneTemporary
Actions

View Options

diff --git a/GUIDE.md b/GUIDE.md
index 9978080..a1fc1f0 100644
--- a/GUIDE.md
+++ b/GUIDE.md
@@ -1,105 +1,106 @@
# Write.as CLI User Guide
The Write.as Command-Line Interface (CLI) is a cross-platform tool for publishing text to [Write.as](https://write.as) and its other sites, like [Paste.as](https://paste.as). It is designed to be simple, scriptable, do one job (publishing) well, and work as you'd expect with other command-line tools.
Write.as is a text-publishing service that protects your privacy. There's no sign up required to publish, but if you do sign up, you can access posts across devices and compile collections of them in what most people would call a "blog".
**Note** accounts are not supported in CLI v1.0. They'll be available in [v2.0](https://github.com/writeas/writeas-cli/milestone/4).
## Uses
These are a few common uses for `writeas`. If you get stuck or want to know more, run `writeas [command] --help`. If you still have questions, [ask us](https://write.as/contact).
### Overview
```
writeas [global options] command [command options] [arguments...]
COMMANDS:
post Alias for default action: create post from stdin
new Compose a new post from the command-line and publish
+ publish Publish a file to Write.as
delete Delete a post
update Update (overwrite) a post
get Read a raw post
add Add an existing post locally
list List local posts
auth Authenticate with Write.as
help, h Shows a list of commands or help for one command
GLOBAL OPTIONS:
--tor, -t Perform action on Tor hidden service
--tor-port value Use a different port to connect to Tor (default: 9150)
--code Specifies this post is code
--verbose, -v Make the operation more talkative
--font value Sets post font to given value (default: "mono")
--user-agent value Sets the User-Agent for API requests
--help, -h show help
--version, -V print the version
```
#### Share something
By default, `writeas` creates a post with a `monospace` typeface that doesn't word wrap (scrolls horizontally). It will return a single line with a URL, and automatically copy that URL to the clipboard:
```bash
$ echo "Hello world!" | writeas
https://write.as/aaaaaaaaaaaa
```
This is generally more useful for posting terminal output or code, like so (the `--code` flag turns on syntax highlighting):
OS X / *nix: `cat writeas/cli.go | writeas --code`
Windows: `type writeas/cli.go | writeas.exe --code`
#### Output a post
This outputs any Write.as post with the given ID.
```bash
$ writeas get aaaaaaaaaaaa
Hello world!
```
#### List all published posts
This lists all posts you've published from your device. Pass the `--url` flag to show the list with full URLs.
```bash
$ writeas list
aaaaaaaaaaaa
```
#### Delete a post
This permanently deletes a post you own.
```bash
$ writeas delete aaaaaaaaaaaa
```
#### Update a post
This completely overwrites an existing post you own.
```bash
$ echo "See you later!" | writeas update aaaaaaaaaaaa
```
### Composing posts
If you simply have a penchant for never leaving your keyboard, `writeas` is great for composing new posts from the command-line. Just use the `new` subcommand.
`writeas new` will open your favorite command-line editor, as specified by your `WRITEAS_EDITOR` or `EDITOR` environment variables (in that order), falling back to `vim` on OS X / *nix.
Customize your post's appearance with the `--font` flag:
| Argument | Appearance (Typeface) | Word Wrap? |
| -------- | --------------------- | ---------- |
| `sans` | Sans-serif (Open Sans) | Yes |
| `serif` | Serif (Lora) | Yes |
| `wrap` | Monospace | Yes |
| `mono` | Monospace | No |
| `code` | Syntax-highlighted monospace | No |
Put it all together, e.g. publish with a sans-serif font: `writeas new --font sans`
diff --git a/README.md b/README.md
index 3469f13..fb4d58a 100644
--- a/README.md
+++ b/README.md
@@ -1,92 +1,93 @@
writeas-cli
===========
![MIT license](https://img.shields.io/github/license/writeas/writeas-cli.svg) [![Go Report Card](https://goreportcard.com/badge/github.com/writeas/writeas-cli)](https://goreportcard.com/report/github.com/writeas/writeas-cli) [![#writeas on freenode](https://img.shields.io/badge/freenode-%23writeas-blue.svg)](http://webchat.freenode.net/?channels=writeas) [![Public Slack discussion](http://slack.write.as/badge.svg)](http://slack.write.as/)
Command line interface for [Write.as](https://write.as). Works on Windows, macOS, and Linux.
## Features
* Publish anonymously to Write.as
* A stable, easy back-end for your GUI app or desktop-based workflow
* Compatible with our [Tor hidden service](http://writeas7pm7rcdqg.onion/)
* Locally keeps track of any posts you make
* Update and delete anonymous posts
* Fetch any post by ID
* Add anonymous post credentials (like for one published with the [Android app](https://play.google.com/store/apps/details?id=com.abunchtell.writeas)) for editing
## Installing
The easiest way to get the CLI is to download a pre-built executable for your OS.
### Download
[![Latest release](https://img.shields.io/github/release/writeas/writeas-cli.svg)](https://github.com/writeas/writeas-cli/releases/latest) ![Total downloads](https://img.shields.io/github/downloads/writeas/writeas-cli/total.svg)
Get the latest version for your operating system as a standalone executable.
**Windows**<br />
Download the [64-bit](https://github.com/writeas/writeas-cli/releases/download/v1.1/writeas_1.1_windows_amd64.zip) or [32-bit](https://github.com/writeas/writeas-cli/releases/download/v1.1/writeas_1.1_windows_386.zip) executable and put it somewhere in your `%PATH%`.
**macOS**<br />
Download the [64-bit](https://github.com/writeas/writeas-cli/releases/download/v1.1/writeas_1.1_darwin_amd64.tar.gz) executable and put it somewhere in your `$PATH`, like `/usr/local/bin`.
**Linux**<br />
Download the [64-bit](https://github.com/writeas/writeas-cli/releases/download/v1.1/writeas_1.1_linux_amd64.tar.gz) or [32-bit](https://github.com/writeas/writeas-cli/releases/download/v1.1/writeas_1.1_linux_386.tar.gz) executable and put it somewhere in your `$PATH`, like `/usr/local/bin`.
### Go get it
```bash
go get github.com/writeas/writeas-cli/cmd/writeas
```
Once this finishes, you'll see `writeas` or `writeas.exe` inside `$GOPATH/bin/`.
## Upgrading
To upgrade the CLI, download and replace the executable you downloaded before.
If you previously installed with `go get`, run it again with the `-u` option.
```bash
go get -u github.com/writeas/writeas-cli/cmd/writeas
```
## Usage
See full usage documentation on our [User Guide](GUIDE.md).
```
writeas [global options] command [command options] [arguments...]
COMMANDS:
post Alias for default action: create post from stdin
new Compose a new post from the command-line and publish
+ publish Publish a file to Write.as
delete Delete a post
update Update (overwrite) a post
get Read a raw post
add Add an existing post locally
list List local posts
auth Authenticate with Write.as
help, h Shows a list of commands or help for one command
GLOBAL OPTIONS:
--tor, -t Perform action on Tor hidden service
--tor-port value Use a different port to connect to Tor (default: 9150)
--code Specifies this post is code
--verbose, -v Make the operation more talkative
--font value Sets post font to given value (default: "mono")
--user-agent value Sets the User-Agent for API requests
--help, -h show help
--version, -V print the version
```
## Contributing to the CLI
For a complete guide to contributing, see the [Contribution Guide](.github/CONTRIBUTING.md).
We welcome any kind of contributions including documentation, organizational improvements, tutorials, bug reports, feature requests, new features, answering questions, etc.
### Getting Support
We're available on [several channels](https://write.as/contact), and prefer the #development channel [in Slack](http://slack.write.as) for project discussion. Please don't use the GitHub issue tracker to ask questions.
### Reporting Issues
If you believe you have found a bug in the CLI or its documentation, file an issue on this repo. If you're not sure if it's a bug or not, [reach out to us](https://write.as/contact) in one way or another. Be sure to provide the version of the CLI (with `writeas --version`) in your report.
diff --git a/cmd/writeas/cli.go b/cmd/writeas/cli.go
index f122d08..fd281bd 100644
--- a/cmd/writeas/cli.go
+++ b/cmd/writeas/cli.go
@@ -1,319 +1,325 @@
package main
import (
"bufio"
"gopkg.in/urfave/cli.v1"
"io"
"log"
"os"
)
// API constants for communicating with Write.as.
const (
writeasBaseURL = "https://write.as"
torBaseURL = "http://writeas7pm7rcdqg.onion"
)
// Application constants.
const (
version = "1.1"
)
// Defaults for posts on Write.as.
const (
defaultFont = PostFontMono
)
// Available flags for creating posts
var postFlags = []cli.Flag{
cli.StringFlag{
Name: "c, b",
Usage: "Optional blog to post to",
Value: "",
},
cli.BoolFlag{
Name: "tor, t",
Usage: "Perform action on Tor hidden service",
},
cli.IntFlag{
Name: "tor-port",
Usage: "Use a different port to connect to Tor",
Value: 9150,
},
cli.BoolFlag{
Name: "code",
Usage: "Specifies this post is code",
},
cli.BoolFlag{
Name: "verbose, v",
Usage: "Make the operation more talkative",
},
cli.StringFlag{
Name: "font",
Usage: "Sets post font to given value",
Value: defaultFont,
},
cli.StringFlag{
Name: "user-agent",
Usage: "Sets the User-Agent for API requests",
Value: "",
},
}
func main() {
initialize()
cli.VersionFlag = cli.BoolFlag{
Name: "version, V",
Usage: "print the version",
}
// Run the app
app := cli.NewApp()
app.Name = "writeas"
app.Version = version
app.Usage = "Publish text quickly"
app.Authors = []cli.Author{
{
Name: "Write.as",
Email: "hello@write.as",
},
}
app.Action = cmdPost
app.Flags = postFlags
app.Commands = []cli.Command{
{
Name: "post",
Usage: "Alias for default action: create post from stdin",
Action: cmdPost,
Flags: postFlags,
Description: `Create a new post on Write.as from stdin.
Use the --code flag to indicate that the post should use syntax
highlighting. Or use the --font [value] argument to set the post's
appearance, where [value] is mono, monospace (default), wrap (monospace
font with word wrapping), serif, or sans.`,
},
{
Name: "new",
Usage: "Compose a new post from the command-line and publish",
Description: `An alternative to piping data to the program.
On Windows, this will use 'copy con' to start reading what you input from the
prompt. Press F6 or Ctrl-Z then Enter to end input.
On *nix, this will use the best available text editor, starting with the
value set to the WRITAS_EDITOR or EDITOR environment variable, or vim, or
finally nano.
Use the --code flag to indicate that the post should use syntax
highlighting. Or use the --font [value] argument to set the post's
appearance, where [value] is mono, monospace (default), wrap (monospace
font with word wrapping), serif, or sans.
If posting fails for any reason, 'writeas' will show you the temporary file
location and how to pipe it to 'writeas' to retry.`,
Action: cmdNew,
Flags: postFlags,
},
+ {
+ Name: "publish",
+ Usage: "Publish a file to Write.as",
+ Action: cmdPublish,
+ Flags: postFlags,
+ },
{
Name: "delete",
Usage: "Delete a post",
Action: cmdDelete,
Flags: []cli.Flag{
cli.BoolFlag{
Name: "tor, t",
Usage: "Delete via Tor hidden service",
},
cli.IntFlag{
Name: "tor-port",
Usage: "Use a different port to connect to Tor",
Value: 9150,
},
},
},
{
Name: "update",
Usage: "Update (overwrite) a post",
Action: cmdUpdate,
Flags: []cli.Flag{
cli.BoolFlag{
Name: "tor, t",
Usage: "Update via Tor hidden service",
},
cli.IntFlag{
Name: "tor-port",
Usage: "Use a different port to connect to Tor",
Value: 9150,
},
cli.BoolFlag{
Name: "code",
Usage: "Specifies this post is code",
},
cli.StringFlag{
Name: "font",
Usage: "Sets post font to given value",
},
},
},
{
Name: "get",
Usage: "Read a raw post",
Action: cmdGet,
Flags: []cli.Flag{
cli.BoolFlag{
Name: "tor, t",
Usage: "Get from Tor hidden service",
},
cli.IntFlag{
Name: "tor-port",
Usage: "Use a different port to connect to Tor",
Value: 9150,
},
},
},
{
Name: "add",
Usage: "Add an existing post locally",
Description: `A way to add an existing post to your local store for easy editing later.
This requires a post ID (from https://write.as/[ID]) and an Edit Token
(exported from another Write.as client, such as the Android app).
`,
Action: cmdAdd,
},
{
Name: "list",
Usage: "List local posts",
Action: cmdList,
Flags: []cli.Flag{
cli.BoolFlag{
Name: "id",
Usage: "Show list with post IDs (default)",
},
cli.BoolFlag{
Name: "url",
Usage: "Show list with URLs",
},
},
},
{
Name: "fetch",
Usage: "Fetch authenticated user's Write.as posts",
Action: cmdPull,
Flags: []cli.Flag{
cli.BoolFlag{
Name: "tor, t",
Usage: "Authenticate via Tor hidden service",
},
cli.IntFlag{
Name: "tor-port",
Usage: "Use a different port to connect to Tor",
Value: 9150,
},
},
},
{
Name: "auth",
Usage: "Authenticate with Write.as",
Action: cmdAuth,
Flags: []cli.Flag{
cli.BoolFlag{
Name: "tor, t",
Usage: "Authenticate via Tor hidden service",
},
cli.IntFlag{
Name: "tor-port",
Usage: "Use a different port to connect to Tor",
Value: 9150,
},
cli.StringFlag{
Name: "u",
Usage: "Username for authentication",
Value: "",
},
},
},
{
Name: "logout",
Usage: "Log out of Write.as",
Action: cmdLogOut,
Flags: []cli.Flag{
cli.BoolFlag{
Name: "tor, t",
Usage: "Authenticate via Tor hidden service",
},
cli.IntFlag{
Name: "tor-port",
Usage: "Use a different port to connect to Tor",
Value: 9150,
},
},
},
}
cli.CommandHelpTemplate = `NAME:
{{.Name}} - {{.Usage}}
USAGE:
writeas {{.Name}}{{if .Flags}} [command options]{{end}} [arguments...]{{if .Description}}
DESCRIPTION:
{{.Description}}{{end}}{{if .Flags}}
OPTIONS:
{{range .Flags}}{{.}}
{{end}}{{ end }}
`
app.Run(os.Args)
}
func initialize() {
// Ensure we have a data directory to use
if !dataDirExists() {
createDataDir()
}
}
func readStdIn() []byte {
numBytes, numChunks := int64(0), int64(0)
r := bufio.NewReader(os.Stdin)
fullPost := []byte{}
buf := make([]byte, 0, 1024)
for {
n, err := r.Read(buf[:cap(buf)])
buf = buf[:n]
if n == 0 {
if err == nil {
continue
}
if err == io.EOF {
break
}
log.Fatal(err)
}
numChunks++
numBytes += int64(len(buf))
fullPost = append(fullPost, buf...)
if err != nil && err != io.EOF {
log.Fatal(err)
}
}
return fullPost
}
func handlePost(fullPost []byte, c *cli.Context) error {
tor := isTor(c)
if c.Int("tor-port") != 0 {
torPort = c.Int("tor-port")
}
if tor {
Info(c, "Posting to hidden service...")
} else {
Info(c, "Posting...")
}
return DoPost(c, fullPost, c.String("font"), false, tor, c.Bool("code"))
}
diff --git a/cmd/writeas/commands.go b/cmd/writeas/commands.go
index f8105fd..f86e843 100644
--- a/cmd/writeas/commands.go
+++ b/cmd/writeas/commands.go
@@ -1,188 +1,201 @@
package main
import (
"fmt"
"github.com/howeyc/gopass"
"gopkg.in/urfave/cli.v1"
+ "io/ioutil"
"os"
)
func cmdPost(c *cli.Context) error {
err := handlePost(readStdIn(), c)
return err
}
func cmdNew(c *cli.Context) error {
fname, p := composeNewPost()
if p == nil {
// Assume composeNewPost already told us what the error was. Abort now.
os.Exit(1)
}
// Ensure we have something to post
if len(*p) == 0 {
// Clean up temporary post
if fname != "" {
os.Remove(fname)
}
InfolnQuit("Empty post. Bye!")
}
err := handlePost(*p, c)
if err != nil {
Errorln("Error posting: %s", err)
Errorln(messageRetryCompose(fname))
return cli.NewExitError("", 1)
}
// Clean up temporary post
if fname != "" {
os.Remove(fname)
}
return nil
}
+func cmdPublish(c *cli.Context) error {
+ filename := c.Args().Get(0)
+ if filename == "" {
+ return cli.NewExitError("usage: writeas publish <filename>", 1)
+ }
+ content, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return err
+ }
+ return handlePost(content, c)
+}
+
func cmdDelete(c *cli.Context) error {
friendlyID := c.Args().Get(0)
token := c.Args().Get(1)
if friendlyID == "" {
return cli.NewExitError("usage: writeas delete <postId> [<token>]", 1)
}
if token == "" {
// Search for the token locally
token = tokenFromID(friendlyID)
if token == "" {
Errorln("Couldn't find an edit token locally. Did you create this post here?")
ErrorlnQuit("If you have an edit token, use: writeas delete %s <token>", friendlyID)
}
}
tor := isTor(c)
if c.Int("tor-port") != 0 {
torPort = c.Int("tor-port")
}
if tor {
Info(c, "Deleting via hidden service...")
} else {
Info(c, "Deleting...")
}
return DoDelete(c, friendlyID, token, tor)
}
func cmdUpdate(c *cli.Context) error {
friendlyID := c.Args().Get(0)
token := c.Args().Get(1)
if friendlyID == "" {
return cli.NewExitError("usage: writeas update <postId> [<token>]", 1)
}
if token == "" {
// Search for the token locally
token = tokenFromID(friendlyID)
if token == "" {
Errorln("Couldn't find an edit token locally. Did you create this post here?")
ErrorlnQuit("If you have an edit token, use: writeas update %s <token>", friendlyID)
}
}
// Read post body
fullPost := readStdIn()
tor := isTor(c)
if c.Int("tor-port") != 0 {
torPort = c.Int("tor-port")
}
if tor {
Info(c, "Updating via hidden service...")
} else {
Info(c, "Updating...")
}
return DoUpdate(c, fullPost, friendlyID, token, c.String("font"), tor, c.Bool("code"))
}
func cmdGet(c *cli.Context) error {
friendlyID := c.Args().Get(0)
if friendlyID == "" {
return cli.NewExitError("usage: writeas get <postId>", 1)
}
tor := isTor(c)
if c.Int("tor-port") != 0 {
torPort = c.Int("tor-port")
}
if tor {
Info(c, "Getting via hidden service...")
} else {
Info(c, "Getting...")
}
return DoFetch(friendlyID, userAgent(c), tor)
}
func cmdAdd(c *cli.Context) error {
friendlyID := c.Args().Get(0)
token := c.Args().Get(1)
if friendlyID == "" || token == "" {
return cli.NewExitError("usage: writeas add <postId> <token>", 1)
}
err := addPost(friendlyID, token)
return err
}
func cmdList(c *cli.Context) error {
urls := c.Bool("url")
ids := c.Bool("id")
var p Post
posts := getPosts()
for i := range *posts {
p = (*posts)[len(*posts)-1-i]
if ids || !urls {
fmt.Printf("%s ", p.ID)
}
if urls {
fmt.Printf("https://write.as/%s ", p.ID)
}
fmt.Print("\n")
}
return nil
}
func cmdAuth(c *cli.Context) error {
// Check configuration
u, err := loadUser()
if err != nil {
return cli.NewExitError(fmt.Sprintf("couldn't load config: %v", err), 1)
}
if u != nil && u.AccessToken != "" {
return cli.NewExitError("You're already authenticated.", 1)
}
// Validate arguments and get password
username := c.String("u")
if username == "" {
return cli.NewExitError("usage: writeas auth -u <username>", 1)
}
fmt.Print("Password: ")
pass, err := gopass.GetPasswdMasked()
if err != nil {
return cli.NewExitError(fmt.Sprintf("error reading password: %v", err), 1)
}
// Validate password
if len(pass) == 0 {
return cli.NewExitError("Please enter your password.", 1)
}
return DoLogIn(c, username, string(pass))
}
func cmdLogOut(c *cli.Context) error {
return DoLogOut(c)
}

File Metadata

Mime Type
text/x-diff
Expires
Thu, May 15, 11:06 AM (22 h, 10 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3239672

Event Timeline

musing studio · developers