func NewCmdListTracking(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "list-tracking",
Usage: "List who you're tracking",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdListTracking{}, "tracking", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "j, json",
Usage: "Output as JSON (default is text).",
},
cli.BoolFlag{
Name: "v, verbose",
Usage: "A full dump, with more gory details.",
},
cli.BoolFlag{
Name: "H, headers",
Usage: "Show column headers.",
},
cli.StringFlag{
Name: "f, filter",
Usage: "Provide a regex filter.",
},
},
}
}
func NewCmdTestFSNotify(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "test-fsnotify",
Usage: "Test kbfs notifications",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdTestFSNotify{Contextified: libkb.NewContextified(g)}, "test-fsnotify", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "p, public",
Usage: "public top level folder",
},
cli.StringFlag{
Name: "f, filename",
Usage: "filename",
},
cli.StringFlag{
Name: "a, action",
Usage: "[encrypting|decrypting|signing|verifying|rekeying]",
},
cli.StringFlag{
Name: "delay",
Usage: "delay between start and finish calls",
},
},
}
}
func NewCmdLogin(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
cmd := cli.Command{
Name: "login",
ArgumentHelp: "[username]",
Usage: "Establish a session with the keybase server",
Action: func(c *cli.Context) {
cl.ChooseCommand(NewCmdLoginRunner(g), "login", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "provision-by-email",
Usage: "Use an email address associated with a keybase account to provision a device",
},
},
}
// Note we'll only be able to set this via mode via Environment variable
// since it's too early to check command-line setting of it.
if g.Env.GetRunMode() == libkb.DevelRunMode {
cmd.Flags = append(cmd.Flags, cli.BoolFlag{
Name: "emulate-gui",
Usage: "emulate GUI signing and fork GPG from the service",
})
}
return cmd
}
func NewCmdUpdateRun(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
defaultOptions := engine.DefaultUpdaterOptions(g)
return cli.Command{
Name: "run",
Flags: []cli.Flag{
cli.StringFlag{
Name: "e, current-version",
Usage: fmt.Sprintf("Current version. Default is %q.", defaultOptions.Version),
},
cli.StringFlag{
Name: "d, destination-path",
Usage: fmt.Sprintf("Destination of where to apply update. Default is %q.", defaultOptions.DestinationPath),
},
cli.StringFlag{
Name: "s, source",
Usage: fmt.Sprintf("Update source (%s). Default is %q.",
sources.UpdateSourcesDescription(", "),
defaultOptions.Source),
},
cli.StringFlag{
Name: "u, url",
Usage: "Custom URL.",
},
cli.BoolFlag{
Name: "f, force",
Usage: "Force update.",
},
},
ArgumentHelp: "",
Usage: "Run the updater",
Action: func(c *cli.Context) {
cl.ChooseCommand(NewCmdUpdateRunRunner(g, defaultOptions), "run", c)
},
}
}
func NewCmdVerify(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "verify",
Usage: "Verify message or file signatures for keybase users",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdVerify{Contextified: libkb.NewContextified(g)}, "verify", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "d, detached",
Usage: "Specify a detached signature file.",
},
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "m, message",
Usage: "Provide the message to verify on the command line.",
},
cli.BoolFlag{
Name: "no-output",
Usage: "Don't output the verified message.",
},
cli.StringFlag{
Name: "o, outfile",
Usage: "Specify an outfile (stdout by default).",
},
cli.StringFlag{
Name: "S, signed-by",
Usage: "Assert signed by the given user (can use user assertion format).",
},
},
}
}
func NewCmdPGPVerify(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "verify",
Usage: "PGP verify message or file signatures for keybase users",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPGPVerify{}, "verify", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "l, local",
Usage: "Only track locally, don't send a statement to the server.",
},
cli.BoolFlag{
Name: "y",
Usage: "Approve remote tracking without prompting.",
},
cli.StringFlag{
Name: "m, message",
Usage: "Provide the message on the command line.",
},
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "d, detached",
Usage: "Specify a detached signature file.",
},
cli.StringFlag{
Name: "S, signed-by",
Usage: "Assert signed by the given user (can use user assertion format).",
},
},
}
}
func NewCmdPGPImport(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "import",
Usage: "Import a PGP key into keybase",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPGPImport{}, "import", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an infile (stdin by default).",
},
cli.BoolFlag{
Name: "push-secret",
Usage: "Push an encrypted copy of the secret key to the server.",
},
},
Description: `"keybase pgp import" imports a PGP secret key for use with Keybase.
It accepts that secret key via file (with the "--infile" flag) or
otherwise via standard input. The secret key is used to sign the
public PGP key into the user's Keybase sigchain. The secret key
is also imported into the local Keybase keyring and encrypted with
the local key security protocol.
If (and only if) the "--push-secret" flag is specified, this command
pushes the PGP secret key to the Keybase server, encrypted with the
user's passphrase. The server, in this case, could theoretically
recover the PGP secret key by cracking the user's passphrase.`,
}
}
// NewCmdProve makes a new prove command from the given CLI parameters.
func NewCmdProve(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
serviceList := strings.Join(libkb.ListProofCheckers(), ", ")
description := fmt.Sprintf("Supported services are: %s.", serviceList)
cmd := cli.Command{
Name: "prove",
ArgumentHelp: "<service> [service username]",
Usage: "Generate a new proof",
Description: description,
Flags: []cli.Flag{
cli.StringFlag{
Name: "output, o",
Usage: "Output proof text to a file (rather than standard out).",
},
cli.BoolFlag{
Name: "force, f",
Usage: "Don't prompt.",
},
},
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdProve{Contextified: libkb.NewContextified(g)}, "prove", c)
},
}
cmd.Flags = append(cmd.Flags, restrictedProveFlags...)
return cmd
}
func NewCmdListTracking(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "list-following",
ArgumentHelp: "<username>",
Usage: "List who you or the given user is following",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdListTracking{Contextified: libkb.NewContextified(g)}, "following", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "f, filter",
Usage: "Provide a regex filter.",
},
cli.BoolFlag{
Name: "H, headers",
Usage: "Show column headers.",
},
cli.BoolFlag{
Name: "j, json",
Usage: "Output as JSON (default is text).",
},
cli.BoolFlag{
Name: "v, verbose",
Usage: "A full dump, with more gory details.",
},
},
}
}
func NewCmdPGPDecrypt(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "decrypt",
Usage: "PGP decrypt messages or files for keybase users",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPGPDecrypt{Contextified: libkb.NewContextified(g)}, "decrypt", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "m, message",
Usage: "Provide the message on the command line.",
},
cli.StringFlag{
Name: "o, outfile",
Usage: "Specify an outfile (stdout by default).",
},
cli.BoolFlag{
Name: "s, signed",
Usage: "Assert signed.",
},
cli.StringFlag{
Name: "S, signed-by",
Usage: "Assert signed by the given user (can use user assertion format).",
},
},
Description: `Use of this command requires at least one PGP secret key imported
into the local Keybase keyring. It will try all secret keys in the local keyring that match the
given ciphertext, and will succeed so long as one such key is available.`,
}
}
func NewCmdTrack(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "follow",
ArgumentHelp: "<username>",
Usage: "Verify a user's authenticity and optionally follow them",
Flags: []cli.Flag{
cli.BoolFlag{
Name: "local, l",
Usage: "Only follow locally, don't send a public statement to the server.",
},
cli.BoolFlag{
Name: "y",
Usage: "Approve remote following without prompting.",
},
cli.BoolFlag{
Name: "s, skip-proof-cache",
Usage: "Skip cached proofs, force re-check",
},
},
Aliases: []string{"track"},
Action: func(c *cli.Context) {
cl.ChooseCommand(NewCmdTrackRunner(g), "follow", c)
},
}
}
func NewCmdUnlock(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "unlock",
Usage: "Unlock local key storage",
Description: `"keybase unlock" can be used to restore access to your local key store
when the keybase service restarts unexpectedly.
During normal operation, there is no need for this command.
During our beta testing period, however, there are times where the
keybase service crashes and restarts itself. If you are logged in
when this happens, you are still logged in, but you lose the ability
to unlock any locally encrypted keys. Instead of logging out and
logging back in, the "keybase unlock" command will restore your local
key store access.`,
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdUnlock{}, "unlock", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "stdin",
Usage: "Read a passphrase from stdin instead of a prompt",
},
},
}
}
func NewCmdPGPExport(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "export",
Usage: "Export a PGP key from keybase",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPGPExport{}, "export", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "o, outfile",
Usage: "Specify an outfile (stdout by default).",
},
cli.BoolFlag{
Name: "s, secret",
Usage: "Export secret key.",
},
cli.StringFlag{
Name: "q, query",
Usage: "Only export keys matching that query.",
},
},
Description: `"keybase pgp export" exports public (and optionally private) PGP keys
from Keybase, and into a file or to standard output. It doesn't access
the GnuGP keychain at all.`,
}
}
// NewCmdListTrackers creates a new cli.Command.
func NewCmdListTrackers(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "list-trackers",
ArgumentHelp: "<username>",
Usage: "List trackers",
Flags: []cli.Flag{
cli.BoolFlag{
Name: "i, uid",
Usage: "Load user by UID.",
},
cli.BoolFlag{
Name: "v, verbose",
Usage: "A full dump, with more gory details.",
},
cli.BoolFlag{
Name: "j, json",
Usage: "Output as JSON (default is text).",
},
cli.BoolFlag{
Name: "H, headers",
Usage: "Show column headers.",
},
},
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdListTrackers{}, "list-trackers", c)
},
}
}
func NewCmdDecrypt(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "decrypt",
Usage: "Decrypt messages or files for keybase users",
Action: func(c *cli.Context) {
cl.ChooseCommand(NewCmdDecryptRunner(g), "decrypt", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "m, message",
Usage: "Provide the message on the command line.",
},
cli.StringFlag{
Name: "o, outfile",
Usage: "Specify an outfile (stdout by default).",
},
cli.BoolFlag{
Name: "interactive",
Usage: "Interactive prompt for decryption after sender verification",
},
cli.BoolFlag{
Name: "f, force",
Usage: "Force unprompted decryption, even on an identify failure",
},
},
}
}
func NewCmdInstall(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "install",
Flags: []cli.Flag{
cli.StringFlag{
Name: "f, force",
Usage: "Force install actions.",
},
cli.StringFlag{
Name: "o, format",
Usage: "Format for output. Specify 'j' for JSON or blank for default.",
},
cli.StringFlag{
Name: "b, bin-path",
Usage: "Full path to the executable, if it would be ambiguous otherwise.",
},
cli.StringFlag{
Name: "i, installer",
Usage: "Installer to use.",
},
cli.StringFlag{
Name: "c, components",
Usage: "Components to install, comma separated. Specify 'cli' for command line, 'service' for service, kbfs for 'kbfs', or blank for all.",
},
},
ArgumentHelp: "",
Usage: "Installs Keybase components",
Action: func(c *cli.Context) {
cl.SetLogForward(libcmdline.LogForwardNone)
cl.SetForkCmd(libcmdline.NoFork)
cl.ChooseCommand(NewCmdInstallRunner(g), "install", c)
},
}
}
func NewCmdSign(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "sign",
Usage: "Sign a document",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdSign{Contextified: libkb.NewContextified(g)}, "sign", c)
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "b, binary",
Usage: "Output binary message (default is armored).",
},
cli.BoolFlag{
Name: "d, detached",
Usage: "Detached signature (default is attached).",
},
cli.StringFlag{
Name: "i, infile",
Usage: "Specify an input file.",
},
cli.StringFlag{
Name: "m, message",
Usage: "Provide the message to sign on the command line.",
},
cli.StringFlag{
Name: "o, outfile",
Usage: "Specify an outfile (default is STDOUT).",
},
},
}
}
func NewCmdLaunchdStatus(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "status",
Flags: []cli.Flag{
cli.StringFlag{
Name: "b, bundle-version",
Usage: "Bundle version",
},
cli.StringFlag{
Name: "f, format",
Usage: "Format for output. Specify 'j' for JSON or blank for default.",
},
},
ArgumentHelp: "<service-name>",
Usage: "Status for keybase launchd service, including for installing or updating",
Action: func(c *cli.Context) {
// This is to bypass the logui protocol registration in main.go which is
// triggering a connection before our Run() is called. See that file for
// more info.
cl.SetLogForward(libcmdline.LogForwardNone)
cl.SetForkCmd(libcmdline.NoFork)
cl.ChooseCommand(NewCmdLaunchdStatusRunner(g), "status", c)
},
}
}
func NewCmdSignup(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
cmd := cli.Command{
Name: "signup",
Usage: "Signup for a new account",
Action: func(c *cli.Context) {
cl.ChooseCommand(NewCmdSignupRunner(g), "signup", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "c, invite-code",
Usage: "Specify an invite code.",
},
cli.StringFlag{
Name: "email",
Usage: "Specify an account email.",
},
cli.StringFlag{
Name: "username",
Usage: "Specify a username.",
},
},
}
cmd.Flags = append(cmd.Flags, extraSignupFlags...)
return cmd
}
func NewCmdService(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "service",
Flags: []cli.Flag{
cli.StringFlag{
Name: "chdir",
Usage: "Specify where to run as a daemon (via chdir)",
},
cli.StringFlag{
Name: "label",
Usage: "Specifying a label can help identify services.",
},
cli.BoolFlag{
Name: "auto-forked",
Usage: "Specify if this binary was auto-forked from the client",
},
cli.BoolFlag{
Name: "watchdog-forked",
Usage: "Specify if this binary was started by the watchdog",
},
},
Action: func(c *cli.Context) {
cl.ChooseCommand(NewService(g, true /* isDaemon */), "service", c)
cl.SetService()
},
}
}
// NewCmdCtlStop constructs ctl start command
func NewCmdCtlStop(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "stop",
Usage: "Stop the app and services",
Flags: []cli.Flag{
cli.StringFlag{
Name: "include",
Usage: fmt.Sprintf("Stop only specified components, comma separated. Specify %v.", availableCtlComponents),
},
cli.StringFlag{
Name: "exclude",
Usage: fmt.Sprintf("Stop all except excluded components, comma separated. Specify %v.", availableCtlComponents),
},
cli.BoolFlag{
Name: "no-wait",
Usage: "If specified we won't wait for services to exit",
},
},
Action: func(c *cli.Context) {
cl.ChooseCommand(newCmdCtlStop(g), "stop", c)
cl.SetForkCmd(libcmdline.NoFork)
cl.SetLogForward(libcmdline.LogForwardNone)
cl.SetNoStandalone()
},
}
}
func NewCmdFakeTrackingChanged(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "fake-following-changed",
Flags: []cli.Flag{},
Action: func(c *cli.Context) {
cl.ChooseCommand(NewCmdFakeTrackingChangedRunner(g), "fake-following-changed", c)
},
}
}
func NewCmdPassphraseRecover(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "recover",
Usage: "Recover your keybase account passphrase",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPassphraseRecover{Contextified: libkb.NewContextified(g)}, "recover", c)
},
}
}
func NewCmdConfigInfo(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "info",
Usage: "Show config file path",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdConfigInfo{}, "info", c)
},
}
}
func NewCmdConfigReset(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "reset",
Usage: "Reset the config",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdConfigReset{}, "reset", c)
},
}
}
func NewCmdFavoriteList(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "list",
Usage: "List favorites",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdFavoriteList{}, "add", c)
},
}
}
func NewCmdTestPassphrase(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "test-passphrase",
Usage: "Test the GetPassphrase protocol",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdTestPassphrase{Contextified: libkb.NewContextified(g)}, "test-passphrase", c)
},
}
}
func NewCmdReset(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "reset",
Usage: "Delete all local cached state",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdReset{}, "reset", c)
},
}
}
func NewCmdPassphraseChange(cl *libcmdline.CommandLine) cli.Command {
return cli.Command{
Name: "change",
Usage: "Change your keybase account passphrase.",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdPassphraseChange{}, "change", c)
},
}
}
func NewCmdLogout(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "logout",
Usage: "Logout and remove session information",
Action: func(c *cli.Context) {
cl.ChooseCommand(NewCmdLogoutRunner(g), "logout", c)
},
}
}
