const (
    ConfigOption  = "config"
    DebugOption   = "debug"
    LocalOption   = "local" // DEPRECATED: use OfflineOption
    OfflineOption = "offline"
    ApiOption     = "api"
)

const P2PProtoPrefix = "/x/"

var ActiveReqsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "List commands run on this IPFS node.",
        ShortDescription: `
Lists running and recently run commands.
`,
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        ctx := env.(*oldcmds.Context)
        return cmds.EmitOnce(res, ctx.ReqLog.Report())
    },
    Options: []cmds.Option{
        cmds.BoolOption(verboseOptionName, "v", "Print extra information."),
    },
    Subcommands: map[string]*cmds.Command{
        "clear":    clearInactiveCmd,
        "set-time": setRequestClearCmd,
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *[]*cmds.ReqLogEntry) error {
            verbose, _ := req.Options[verboseOptionName].(bool)

            tw := tabwriter.NewWriter(w, 4, 4, 2, ' ', 0)
            if verbose {
                fmt.Fprint(tw, "ID\t")
            }
            fmt.Fprint(tw, "Command\t")
            if verbose {
                fmt.Fprint(tw, "Arguments\tOptions\t")
            }
            fmt.Fprintln(tw, "Active\tStartTime\tRunTime")

            for _, req := range *out {
                if verbose {
                    fmt.Fprintf(tw, "%d\t", req.ID)
                }
                fmt.Fprintf(tw, "%s\t", req.Command)
                if verbose {
                    fmt.Fprintf(tw, "%v\t[", req.Args)
                    var keys []string
                    for k := range req.Options {
                        keys = append(keys, k)
                    }
                    sort.Strings(keys)

                    for _, k := range keys {
                        fmt.Fprintf(tw, "%s=%v,", k, req.Options[k])
                    }
                    fmt.Fprintf(tw, "]\t")
                }

                var live time.Duration
                if req.Active {
                    live = time.Since(req.StartTime)
                } else {
                    live = req.EndTime.Sub(req.StartTime)
                }
                t := req.StartTime.Format(time.Stamp)
                fmt.Fprintf(tw, "%t\t%s\t%s\n", req.Active, t, live)
            }
            tw.Flush()

            return nil
        }),
    },
    Type: []*cmds.ReqLogEntry{},
}

var AddCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Add a file or directory to ipfs.",
        ShortDescription: `
Adds contents of <path> to ipfs. Use -r to add directories (recursively).
`,
        LongDescription: "" /* 2170 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.FileArg("path", true, true, "The path to a file to be added to ipfs.").EnableRecursive().EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.OptionRecursivePath,
        cmds.OptionDerefArgs,
        cmds.OptionStdinName,
        cmds.OptionHidden,
        cmds.BoolOption(quietOptionName, "q", "Write minimal output."),
        cmds.BoolOption(quieterOptionName, "Q", "Write only final hash."),
        cmds.BoolOption(silentOptionName, "Write no output."),
        cmds.BoolOption(progressOptionName, "p", "Stream progress data."),
        cmds.BoolOption(trickleOptionName, "t", "Use trickle-dag format for dag generation."),
        cmds.BoolOption(onlyHashOptionName, "n", "Only chunk and hash - do not write to disk."),
        cmds.BoolOption(wrapOptionName, "w", "Wrap files with a directory object."),
        cmds.StringOption(chunkerOptionName, "s", "Chunking algorithm, size-[bytes], rabin-[min]-[avg]-[max] or buzhash").WithDefault("size-262144"),
        cmds.BoolOption(pinOptionName, "Pin this object when adding.").WithDefault(true),
        cmds.BoolOption(rawLeavesOptionName, "Use raw blocks for leaf nodes. (experimental)"),
        cmds.BoolOption(noCopyOptionName, "Add the file using filestore. Implies raw-leaves. (experimental)"),
        cmds.BoolOption(fstoreCacheOptionName, "Check the filestore for pre-existing blocks. (experimental)"),
        cmds.IntOption(cidVersionOptionName, "CID version. Defaults to 0 unless an option that depends on CIDv1 is passed. (experimental)"),
        cmds.StringOption(hashOptionName, "Hash function to use. Implies CIDv1 if not sha2-256. (experimental)").WithDefault("sha2-256"),
        cmds.BoolOption(inlineOptionName, "Inline small blocks into CIDs. (experimental)"),
        cmds.IntOption(inlineLimitOptionName, "Maximum block size to inline. (experimental)").WithDefault(32),
    },
    PreRun: func(req *cmds.Request, env cmds.Environment) error {
        quiet, _ := req.Options[quietOptionName].(bool)
        quieter, _ := req.Options[quieterOptionName].(bool)
        quiet = quiet || quieter

        silent, _ := req.Options[silentOptionName].(bool)

        if quiet || silent {
            return nil
        }

        _, found := req.Options[progressOptionName].(bool)
        if !found {
            req.Options[progressOptionName] = true
        }

        return nil
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        progress, _ := req.Options[progressOptionName].(bool)
        trickle, _ := req.Options[trickleOptionName].(bool)
        wrap, _ := req.Options[wrapOptionName].(bool)
        hash, _ := req.Options[onlyHashOptionName].(bool)
        silent, _ := req.Options[silentOptionName].(bool)
        chunker, _ := req.Options[chunkerOptionName].(string)
        dopin, _ := req.Options[pinOptionName].(bool)
        rawblks, rbset := req.Options[rawLeavesOptionName].(bool)
        nocopy, _ := req.Options[noCopyOptionName].(bool)
        fscache, _ := req.Options[fstoreCacheOptionName].(bool)
        cidVer, cidVerSet := req.Options[cidVersionOptionName].(int)
        hashFunStr, _ := req.Options[hashOptionName].(string)
        inline, _ := req.Options[inlineOptionName].(bool)
        inlineLimit, _ := req.Options[inlineLimitOptionName].(int)

        hashFunCode, ok := mh.Names[strings.ToLower(hashFunStr)]
        if !ok {
            return fmt.Errorf("unrecognized hash function: %s", strings.ToLower(hashFunStr))
        }

        enc, err := cmdenv.GetCidEncoder(req)
        if err != nil {
            return err
        }

        toadd := req.Files
        if wrap {
            toadd = files.NewSliceDirectory([]files.DirEntry{
                files.FileEntry("", req.Files),
            })
        }

        opts := []options.UnixfsAddOption{
            options.Unixfs.Hash(hashFunCode),

            options.Unixfs.Inline(inline),
            options.Unixfs.InlineLimit(inlineLimit),

            options.Unixfs.Chunker(chunker),

            options.Unixfs.Pin(dopin),
            options.Unixfs.HashOnly(hash),
            options.Unixfs.FsCache(fscache),
            options.Unixfs.Nocopy(nocopy),

            options.Unixfs.Progress(progress),
            options.Unixfs.Silent(silent),
        }

        if cidVerSet {
            opts = append(opts, options.Unixfs.CidVersion(cidVer))
        }

        if rbset {
            opts = append(opts, options.Unixfs.RawLeaves(rawblks))
        }

        if trickle {
            opts = append(opts, options.Unixfs.Layout(options.TrickleLayout))
        }

        opts = append(opts, nil)

        var added int
        addit := toadd.Entries()
        for addit.Next() {
            _, dir := addit.Node().(files.Directory)
            errCh := make(chan error, 1)
            events := make(chan interface{}, adderOutChanSize)
            opts[len(opts)-1] = options.Unixfs.Events(events)

            go func() {
                var err error
                defer close(events)
                _, err = api.Unixfs().Add(req.Context, addit.Node(), opts...)
                errCh <- err
            }()

            for event := range events {
                output, ok := event.(*coreiface.AddEvent)
                if !ok {
                    return errors.New("unknown event type")
                }

                h := ""
                if output.Path != nil {
                    h = enc.Encode(output.Path.Cid())
                }

                if !dir && addit.Name() != "" {
                    output.Name = addit.Name()
                } else {
                    output.Name = path.Join(addit.Name(), output.Name)
                }

                if err := res.Emit(&AddEvent{
                    Name:  output.Name,
                    Hash:  h,
                    Bytes: output.Bytes,
                    Size:  output.Size,
                }); err != nil {
                    return err
                }
            }

            if err := <-errCh; err != nil {
                return err
            }
            added++
        }

        if addit.Err() != nil {
            return addit.Err()
        }

        if added == 0 {
            return fmt.Errorf("expected a file argument")
        }

        return nil
    },
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            sizeChan := make(chan int64, 1)
            outChan := make(chan interface{})
            req := res.Request()

            go func() {
                size, err := req.Files.Size()
                if err != nil {
                    log.Warningf("error getting files size: %s", err)

                    return
                }

                sizeChan <- size
            }()

            progressBar := func(wait chan struct{}) {
                defer close(wait)

                quiet, _ := req.Options[quietOptionName].(bool)
                quieter, _ := req.Options[quieterOptionName].(bool)
                quiet = quiet || quieter

                progress, _ := req.Options[progressOptionName].(bool)

                var bar *pb.ProgressBar
                if progress {
                    bar = pb.New64(0).SetUnits(pb.U_BYTES)
                    bar.ManualUpdate = true
                    bar.ShowTimeLeft = false
                    bar.ShowPercent = false
                    bar.Output = os.Stderr
                    bar.Start()
                }

                lastFile := ""
                lastHash := ""
                var totalProgress, prevFiles, lastBytes int64

            LOOP:
                for {
                    select {
                    case out, ok := <-outChan:
                        if !ok {
                            if quieter {
                                fmt.Fprintln(os.Stdout, lastHash)
                            }

                            break LOOP
                        }
                        output := out.(*AddEvent)
                        if len(output.Hash) > 0 {
                            lastHash = output.Hash
                            if quieter {
                                continue
                            }

                            if progress {

                                fmt.Fprintf(os.Stderr, "\033[2K\r")
                            }
                            if quiet {
                                fmt.Fprintf(os.Stdout, "%s\n", output.Hash)
                            } else {
                                fmt.Fprintf(os.Stdout, "added %s %s\n", output.Hash, output.Name)
                            }

                        } else {
                            if !progress {
                                continue
                            }

                            if len(lastFile) == 0 {
                                lastFile = output.Name
                            }
                            if output.Name != lastFile || output.Bytes < lastBytes {
                                prevFiles += lastBytes
                                lastFile = output.Name
                            }
                            lastBytes = output.Bytes
                            delta := prevFiles + lastBytes - totalProgress
                            totalProgress = bar.Add64(delta)
                        }

                        if progress {
                            bar.Update()
                        }
                    case size := <-sizeChan:
                        if progress {
                            bar.Total = size
                            bar.ShowPercent = true
                            bar.ShowBar = true
                            bar.ShowTimeLeft = true
                        }
                    case <-req.Context.Done():

                        return
                    }
                }

                if progress && bar.Total == 0 && bar.Get() != 0 {
                    bar.Total = bar.Get()
                    bar.ShowPercent = true
                    bar.ShowBar = true
                    bar.ShowTimeLeft = true
                    bar.Update()
                }
            }

            if e := res.Error(); e != nil {
                close(outChan)
                return e
            }

            wait := make(chan struct{})
            go progressBar(wait)

            defer func() { <-wait }()
            defer close(outChan)

            for {
                v, err := res.Next()
                if err != nil {
                    if err == io.EOF {
                        return nil
                    }

                    return err
                }

                select {
                case outChan <- v:
                case <-req.Context.Done():
                    return req.Context.Err()
                }
            }
        },
    },
    Type: AddEvent{},
}

var BitswapCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with the bitswap agent.",
        ShortDescription: ``,
    },

    Subcommands: map[string]*cmds.Command{
        "stat":      bitswapStatCmd,
        "wantlist":  showWantlistCmd,
        "ledger":    ledgerCmd,
        "reprovide": reprovideCmd,
    },
}

var BlockCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with raw IPFS blocks.",
        ShortDescription: "" /* 153 byte string literal not displayed */,
    },

    Subcommands: map[string]*cmds.Command{
        "stat": blockStatCmd,
        "get":  blockGetCmd,
        "put":  blockPutCmd,
        "rm":   blockRmCmd,
    },
}

var BootstrapCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Show or edit the list of bootstrap peers.",
        ShortDescription: `
Running 'ipfs bootstrap' with no arguments will run 'ipfs bootstrap list'.
` + bootstrapSecurityWarning,
    },

    Run:      bootstrapListCmd.Run,
    Encoders: bootstrapListCmd.Encoders,
    Type:     bootstrapListCmd.Type,

    Subcommands: map[string]*cmds.Command{
        "list": bootstrapListCmd,
        "add":  bootstrapAddCmd,
        "rm":   bootstrapRemoveCmd,
    },
}

var CatCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Show IPFS object data.",
        ShortDescription: "Displays the data contained by an IPFS or IPNS object(s) at the given path.",
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("ipfs-path", true, true, "The path to the IPFS object(s) to be outputted.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.Int64Option(offsetOptionName, "o", "Byte offset to begin reading from."),
        cmds.Int64Option(lengthOptionName, "l", "Maximum number of bytes to read."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        offset, _ := req.Options[offsetOptionName].(int64)
        if offset < 0 {
            return fmt.Errorf("cannot specify negative offset")
        }

        max, found := req.Options[lengthOptionName].(int64)

        if max < 0 {
            return fmt.Errorf("cannot specify negative length")
        }
        if !found {
            max = -1
        }

        err = req.ParseBodyArgs()
        if err != nil {
            return err
        }

        readers, length, err := cat(req.Context, api, req.Arguments, int64(offset), int64(max))
        if err != nil {
            return err
        }

        res.SetLength(length)
        reader := io.MultiReader(readers...)

        return res.Emit(reader)
    },
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            if res.Length() > 0 && res.Length() < progressBarMinSize {
                return cmds.Copy(re, res)
            }

            for {
                v, err := res.Next()
                if err != nil {
                    if err == io.EOF {
                        return nil
                    }
                    return err
                }

                switch val := v.(type) {
                case io.Reader:
                    bar, reader := progressBarForReader(os.Stderr, val, int64(res.Length()))
                    bar.Start()

                    err = re.Emit(reader)
                    if err != nil {
                        return err
                    }
                default:
                    log.Warningf("cat postrun: received unexpected type %T", val)
                }
            }
        },
    },
}

var CidCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Convert and discover properties of CIDs",
    },
    Subcommands: map[string]*cmds.Command{
        "format": cidFmtCmd,
        "base32": base32Cmd,
        "bases":  basesCmd,
        "codecs": codecsCmd,
        "hashes": hashesCmd,
    },
}

var CommandsDaemonCmd = CommandsCmd(Root)

var CommandsDaemonROCmd = CommandsCmd(RootRO)

var ConfigCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Get and set ipfs config values.",
        ShortDescription: "" /* 160 byte string literal not displayed */,

        LongDescription: "" /* 347 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "show":    configShowCmd,
        "edit":    configEditCmd,
        "replace": configReplaceCmd,
        "profile": configProfileCmd,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("key", true, false, "The key of the config entry (e.g. \"Addresses.API\")."),
        cmds.StringArg("value", false, false, "The value to set the config entry to."),
    },
    Options: []cmds.Option{
        cmds.BoolOption(configBoolOptionName, "Set a boolean value."),
        cmds.BoolOption(configJSONOptionName, "Parse stringified JSON."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        args := req.Arguments
        key := args[0]

        var output *ConfigField

        switch strings.ToLower(key) {
        case "identity", "identity.privkey":
            return errors.New("cannot show or change private key through API")
        default:
        }

        cfgRoot, err := cmdenv.GetConfigRoot(env)
        if err != nil {
            return err
        }
        r, err := fsrepo.Open(cfgRoot)
        if err != nil {
            return err
        }
        defer r.Close()
        if len(args) == 2 {
            value := args[1]

            if parseJSON, _ := req.Options[configJSONOptionName].(bool); parseJSON {
                var jsonVal interface{}
                if err := json.Unmarshal([]byte(value), &jsonVal); err != nil {
                    err = fmt.Errorf("failed to unmarshal json. %s", err)
                    return err
                }

                output, err = setConfig(r, key, jsonVal)
            } else if isbool, _ := req.Options[configBoolOptionName].(bool); isbool {
                output, err = setConfig(r, key, value == "true")
            } else {
                output, err = setConfig(r, key, value)
            }
        } else {
            output, err = getConfig(r, key)
        }

        if err != nil {
            return err
        }

        return cmds.EmitOnce(res, output)
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *ConfigField) error {
            if len(req.Arguments) == 2 {
                return nil
            }

            buf, err := config.HumanOutput(out.Value)
            if err != nil {
                return err
            }
            buf = append(buf, byte('\n'))

            _, err = w.Write(buf)
            return err
        }),
    },
    Type: ConfigField{},
}

var DNSCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Resolve DNS links.",
        ShortDescription: "" /* 266 byte string literal not displayed */,

        LongDescription: "" /* 877 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("domain-name", true, false, "The domain-name name to resolve.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.BoolOption(dnsRecursiveOptionName, "r", "Resolve until the result is not a DNS link.").WithDefault(true),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        recursive, _ := req.Options[dnsRecursiveOptionName].(bool)
        name := req.Arguments[0]
        resolver := namesys.NewDNSResolver()

        var routing []nsopts.ResolveOpt
        if !recursive {
            routing = append(routing, nsopts.Depth(1))
        }

        output, err := resolver.Resolve(req.Context, name, routing...)
        if err != nil && (recursive || err != namesys.ErrResolveRecursion) {
            return err
        }
        return cmds.EmitOnce(res, &ncmd.ResolvedPath{Path: output})
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *ncmd.ResolvedPath) error {
            fmt.Fprintln(w, out.Path.String())
            return nil
        }),
    },
    Type: ncmd.ResolvedPath{},
}

var DefaultBufSize = 1048576

var DhtCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Issue commands directly through the DHT.",
        ShortDescription: ``,
    },

    Subcommands: map[string]*cmds.Command{
        "query":     queryDhtCmd,
        "findprovs": findProvidersDhtCmd,
        "findpeer":  findPeerDhtCmd,
        "get":       getValueDhtCmd,
        "put":       putValueDhtCmd,
        "provide":   provideRefDhtCmd,
    },
}

var DiagCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Generate diagnostic reports.",
    },

    Subcommands: map[string]*cmds.Command{
        "sys":  sysDiagCmd,
        "cmds": ActiveReqsCmd,
    },
}

var ErrDepthLimitExceeded = fmt.Errorf("depth limit exceeded")

var ErrInvalidCompressionLevel = errors.New("compression level must be between 1 and 9")

var ErrNotDHT = errors.New("routing service is not a DHT")

var ErrNotOnline = errors.New("this command must be run in online mode. Try running 'ipfs daemon' first")

var ErrPingSelf = errors.New("error: can't ping self")

var FileStoreCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Interact with filestore objects.",
    },
    Subcommands: map[string]*cmds.Command{
        "ls":     lsFileStore,
        "verify": verifyFileStore,
        "dups":   dupsFileStore,
    },
}

var FilesCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with unixfs files.",
        ShortDescription: "" /* 554 byte string literal not displayed */,
    },
    Options: []cmds.Option{
        cmds.BoolOption(filesFlushOptionName, "f", "Flush target and ancestors after write.").WithDefault(true),
    },
    Subcommands: map[string]*cmds.Command{
        "read":  filesReadCmd,
        "write": filesWriteCmd,
        "mv":    filesMvCmd,
        "cp":    filesCpCmd,
        "ls":    filesLsCmd,
        "mkdir": filesMkdirCmd,
        "stat":  filesStatCmd,
        "rm":    filesRmCmd,
        "flush": filesFlushCmd,
        "chcid": filesChcidCmd,
    },
}

var GetCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Download IPFS objects.",
        ShortDescription: "" /* 441 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("ipfs-path", true, false, "The path to the IPFS object(s) to be outputted.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.StringOption(outputOptionName, "o", "The path where the output should be stored."),
        cmds.BoolOption(archiveOptionName, "a", "Output a TAR archive."),
        cmds.BoolOption(compressOptionName, "C", "Compress the output with GZIP compression."),
        cmds.IntOption(compressionLevelOptionName, "l", "The level of compression (1-9)."),
    },
    PreRun: func(req *cmds.Request, env cmds.Environment) error {
        _, err := getCompressOptions(req)
        return err
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        cmplvl, err := getCompressOptions(req)
        if err != nil {
            return err
        }

        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        p := path.New(req.Arguments[0])

        file, err := api.Unixfs().Get(req.Context, p)
        if err != nil {
            return err
        }

        size, err := file.Size()
        if err != nil {
            return err
        }

        res.SetLength(uint64(size))

        archive, _ := req.Options[archiveOptionName].(bool)
        reader, err := fileArchive(file, p.String(), archive, cmplvl)
        if err != nil {
            return err
        }

        return res.Emit(reader)
    },
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            req := res.Request()

            v, err := res.Next()
            if err != nil {
                return err
            }

            outReader, ok := v.(io.Reader)
            if !ok {
                return e.New(e.TypeErr(outReader, v))
            }

            outPath := getOutPath(req)

            cmplvl, err := getCompressOptions(req)
            if err != nil {
                return err
            }

            archive, _ := req.Options[archiveOptionName].(bool)

            gw := getWriter{
                Out:         os.Stdout,
                Err:         os.Stderr,
                Archive:     archive,
                Compression: cmplvl,
                Size:        int64(res.Length()),
            }

            return gw.Write(outReader, outPath)
        },
    },
}

var IDCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Show ipfs node id info.",
        ShortDescription: "" /* 408 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("peerid", false, false, "Peer.ID of node to look up."),
    },
    Options: []cmds.Option{
        cmds.StringOption(formatOptionName, "f", "Optional output format."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        n, err := cmdenv.GetNode(env)
        if err != nil {
            return err
        }

        var id peer.ID
        if len(req.Arguments) > 0 {
            var err error
            id, err = peer.IDB58Decode(req.Arguments[0])
            if err != nil {
                return fmt.Errorf("invalid peer id")
            }
        } else {
            id = n.Identity
        }

        if id == n.Identity {
            output, err := printSelf(n)
            if err != nil {
                return err
            }
            return cmds.EmitOnce(res, output)
        }

        if !n.IsOnline {
            return errors.New(offlineIdErrorMessage)
        }

        p, err := n.Routing.FindPeer(req.Context, id)
        if err == kb.ErrLookupFailure {
            return errors.New(offlineIdErrorMessage)
        }
        if err != nil {
            return err
        }

        output, err := printPeer(n.Peerstore, p.ID)
        if err != nil {
            return err
        }
        return cmds.EmitOnce(res, output)
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *IdOutput) error {
            format, found := req.Options[formatOptionName].(string)
            if found {
                output := format
                output = strings.Replace(output, "<id>", out.ID, -1)
                output = strings.Replace(output, "<aver>", out.AgentVersion, -1)
                output = strings.Replace(output, "<pver>", out.ProtocolVersion, -1)
                output = strings.Replace(output, "<pubkey>", out.PublicKey, -1)
                output = strings.Replace(output, "<addrs>", strings.Join(out.Addresses, "\n"), -1)
                output = strings.Replace(output, "\\n", "\n", -1)
                output = strings.Replace(output, "\\t", "\t", -1)
                fmt.Fprint(w, output)
            } else {
                marshaled, err := json.MarshalIndent(out, "", "\t")
                if err != nil {
                    return err
                }
                marshaled = append(marshaled, byte('\n'))
                fmt.Fprintln(w, string(marshaled))
            }
            return nil
        }),
    },
    Type: IdOutput{},
}

var KeyCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Create and list IPNS name keypairs",
        ShortDescription: "" /* 258 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "gen":    keyGenCmd,
        "list":   keyListCmd,
        "rename": keyRenameCmd,
        "rm":     keyRmCmd,
    },
}

var LogCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with the daemon log output.",
        ShortDescription: "" /* 414 byte string literal not displayed */,
    },

    Subcommands: map[string]*cmds.Command{
        "level": logLevelCmd,
        "ls":    logLsCmd,
        "tail":  logTailCmd,
    },
}

var LsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "List directory contents for Unix filesystem objects.",
        ShortDescription: "" /* 199 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("ipfs-path", true, true, "The path to the IPFS object(s) to list links from.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.BoolOption(lsHeadersOptionNameTime, "v", "Print table headers (Hash, Size, Name)."),
        cmds.BoolOption(lsResolveTypeOptionName, "Resolve linked objects to find out their types.").WithDefault(true),
        cmds.BoolOption(lsSizeOptionName, "Resolve linked objects to find out their file size.").WithDefault(true),
        cmds.BoolOption(lsStreamOptionName, "s", "Enable experimental streaming of directory entries as they are traversed."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        resolveType, _ := req.Options[lsResolveTypeOptionName].(bool)
        resolveSize, _ := req.Options[lsSizeOptionName].(bool)
        stream, _ := req.Options[lsStreamOptionName].(bool)

        err = req.ParseBodyArgs()
        if err != nil {
            return err
        }
        paths := req.Arguments

        enc, err := cmdenv.GetCidEncoder(req)
        if err != nil {
            return err
        }

        var processLink func(path string, link LsLink) error
        var dirDone func(i int)

        processDir := func() (func(path string, link LsLink) error, func(i int)) {
            return func(path string, link LsLink) error {
                output := []LsObject{{
                    Hash:  path,
                    Links: []LsLink{link},
                }}
                return res.Emit(&LsOutput{output})
            }, func(i int) {}
        }
        done := func() error { return nil }

        if !stream {
            output := make([]LsObject, len(req.Arguments))

            processDir = func() (func(path string, link LsLink) error, func(i int)) {

                outputLinks := make([]LsLink, 0)
                return func(path string, link LsLink) error {

                        outputLinks = append(outputLinks, link)
                        return nil
                    }, func(i int) {

                        sort.Slice(outputLinks, func(i, j int) bool {
                            return outputLinks[i].Name < outputLinks[j].Name
                        })

                        output[i] = LsObject{
                            Hash:  paths[i],
                            Links: outputLinks,
                        }
                    }
            }

            done = func() error {
                return cmds.EmitOnce(res, &LsOutput{output})
            }
        }

        for i, fpath := range paths {
            results, err := api.Unixfs().Ls(req.Context, path.New(fpath),
                options.Unixfs.ResolveChildren(resolveSize || resolveType))
            if err != nil {
                return err
            }

            processLink, dirDone = processDir()
            for link := range results {
                if link.Err != nil {
                    return link.Err
                }
                var ftype unixfs_pb.Data_DataType
                switch link.Type {
                case iface.TFile:
                    ftype = unixfs.TFile
                case iface.TDirectory:
                    ftype = unixfs.TDirectory
                case iface.TSymlink:
                    ftype = unixfs.TSymlink
                }
                lsLink := LsLink{
                    Name: link.Name,
                    Hash: enc.Encode(link.Cid),

                    Size:   link.Size,
                    Type:   ftype,
                    Target: link.Target,
                }
                if err := processLink(paths[i], lsLink); err != nil {
                    return err
                }
            }
            dirDone(i)
        }
        return done()
    },
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            req := res.Request()
            lastObjectHash := ""

            for {
                v, err := res.Next()
                if err != nil {
                    if err == io.EOF {
                        return nil
                    }
                    return err
                }
                out := v.(*LsOutput)
                lastObjectHash = tabularOutput(req, os.Stdout, out, lastObjectHash, false)
            }
        },
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *LsOutput) error {

            ignoreBreaks, _ := req.Options[lsStreamOptionName].(bool)
            tabularOutput(req, w, out, "", ignoreBreaks)
            return nil
        }),
    },
    Type: LsOutput{},
}

var MountCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Mounts IPFS to the filesystem (read-only).",
        ShortDescription: "" /* 381 byte string literal not displayed */,

        LongDescription: "" /* 1114 byte string literal not displayed */,
    },
    Options: []cmds.Option{
        cmds.StringOption(mountIPFSPathOptionName, "f", "The path where IPFS should be mounted."),
        cmds.StringOption(mountIPNSPathOptionName, "n", "The path where IPNS should be mounted."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        cfg, err := cmdenv.GetConfig(env)
        if err != nil {
            return err
        }

        nd, err := cmdenv.GetNode(env)
        if err != nil {
            return err
        }

        if !nd.IsOnline {
            return ErrNotOnline
        }

        fsdir, found := req.Options[mountIPFSPathOptionName].(string)
        if !found {
            fsdir = cfg.Mounts.IPFS
        }

        nsdir, found := req.Options[mountIPNSPathOptionName].(string)
        if !found {
            nsdir = cfg.Mounts.IPNS
        }

        err = nodeMount.Mount(nd, fsdir, nsdir)
        if err != nil {
            return err
        }

        var output config.Mounts
        output.IPFS = fsdir
        output.IPNS = nsdir
        return cmds.EmitOnce(res, &output)
    },
    Type: config.Mounts{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, mounts *config.Mounts) error {
            fmt.Fprintf(w, "IPFS mounted at: %s\n", mounts.IPFS)
            fmt.Fprintf(w, "IPNS mounted at: %s\n", mounts.IPNS)

            return nil
        }),
    },
}

var P2PCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Libp2p stream mounting.",
        ShortDescription: "" /* 144 byte string literal not displayed */,
    },

    Subcommands: map[string]*cmds.Command{
        "stream":  p2pStreamCmd,
        "forward": p2pForwardCmd,
        "listen":  p2pListenCmd,
        "close":   p2pCloseCmd,
        "ls":      p2pLsCmd,
    },
}

var PinCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Pin (and unpin) objects to local storage.",
    },

    Subcommands: map[string]*cmds.Command{
        "add":    addPinCmd,
        "rm":     rmPinCmd,
        "ls":     listPinCmd,
        "verify": verifyPinCmd,
        "update": updatePinCmd,
    },
}

var PingCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Send echo request packets to IPFS hosts.",
        ShortDescription: "" /* 181 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("peer ID", true, true, "ID of peer to be pinged.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.IntOption(pingCountOptionName, "n", "Number of ping messages to send.").WithDefault(10),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        n, err := cmdenv.GetNode(env)
        if err != nil {
            return err
        }

        if !n.IsOnline {
            return ErrNotOnline
        }

        addr, pid, err := ParsePeerParam(req.Arguments[0])
        if err != nil {
            return fmt.Errorf("failed to parse peer address '%s': %s", req.Arguments[0], err)
        }

        if pid == n.Identity {
            return ErrPingSelf
        }

        if addr != nil {
            n.Peerstore.AddAddr(pid, addr, pstore.TempAddrTTL)
        }

        numPings, _ := req.Options[pingCountOptionName].(int)
        if numPings <= 0 {
            return fmt.Errorf("ping count must be greater than 0, was %d", numPings)
        }

        if len(n.Peerstore.Addrs(pid)) == 0 {

            if err := res.Emit(&PingResult{
                Text:    fmt.Sprintf("Looking up peer %s", pid.Pretty()),
                Success: true,
            }); err != nil {
                return err
            }

            ctx, cancel := context.WithTimeout(req.Context, kPingTimeout)
            p, err := n.Routing.FindPeer(ctx, pid)
            cancel()
            if err != nil {
                return fmt.Errorf("peer lookup failed: %s", err)
            }
            n.Peerstore.AddAddrs(p.ID, p.Addrs, pstore.TempAddrTTL)
        }

        if err := res.Emit(&PingResult{
            Text:    fmt.Sprintf("PING %s.", pid.Pretty()),
            Success: true,
        }); err != nil {
            return err
        }

        ctx, cancel := context.WithTimeout(req.Context, kPingTimeout*time.Duration(numPings))
        defer cancel()
        pings := ping.Ping(ctx, n.PeerHost, pid)

        var (
            count int
            total time.Duration
        )
        ticker := time.NewTicker(time.Second)
        defer ticker.Stop()

        for i := 0; i < numPings; i++ {
            r, ok := <-pings
            if !ok {
                break
            }

            if r.Error != nil {
                err = res.Emit(&PingResult{
                    Success: false,
                    Text:    fmt.Sprintf("Ping error: %s", r.Error),
                })
            } else {
                count++
                total += r.RTT
                err = res.Emit(&PingResult{
                    Success: true,
                    Time:    r.RTT,
                })
            }
            if err != nil {
                return err
            }

            select {
            case <-ticker.C:
            case <-ctx.Done():
                return ctx.Err()
            }
        }
        if count == 0 {
            return fmt.Errorf("ping failed")
        }
        averagems := total.Seconds() * 1000 / float64(count)
        return res.Emit(&PingResult{
            Success: true,
            Text:    fmt.Sprintf("Average latency: %.2fms", averagems),
        })
    },
    Type: PingResult{},
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            var (
                total time.Duration
                count int
            )

            for {
                event, err := res.Next()
                switch err {
                case nil:
                case io.EOF:
                    return nil
                case context.Canceled, context.DeadlineExceeded:
                    if count == 0 {
                        return err
                    }
                    averagems := total.Seconds() * 1000 / float64(count)
                    return re.Emit(&PingResult{
                        Success: true,
                        Text:    fmt.Sprintf("Average latency: %.2fms", averagems),
                    })
                default:
                    return err
                }

                pr := event.(*PingResult)
                if pr.Success && pr.Text == "" {
                    total += pr.Time
                    count++
                }
                err = re.Emit(event)
                if err != nil {
                    return err
                }
            }
        },
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *PingResult) error {
            if len(out.Text) > 0 {
                fmt.Fprintln(w, out.Text)
            } else if out.Success {
                fmt.Fprintf(w, "Pong received: time=%.2f ms\n", out.Time.Seconds()*1000)
            } else {
                fmt.Fprintf(w, "Pong failed\n")
            }
            return nil
        }),
    },
}

var PubsubCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "An experimental publish-subscribe system on ipfs.",
        ShortDescription: "" /* 301 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "pub":   PubsubPubCmd,
        "sub":   PubsubSubCmd,
        "ls":    PubsubLsCmd,
        "peers": PubsubPeersCmd,
    },
}

var PubsubLsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "List subscribed topics by name.",
        ShortDescription: "" /* 262 byte string literal not displayed */,
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        l, err := api.PubSub().Ls(req.Context)
        if err != nil {
            return err
        }

        return cmds.EmitOnce(res, stringList{l})
    },
    Type: stringList{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(stringListEncoder),
    },
}

var PubsubPeersCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "List peers we are currently pubsubbing with.",
        ShortDescription: "" /* 365 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("topic", false, false, "topic to list connected peers of"),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        var topic string
        if len(req.Arguments) == 1 {
            topic = req.Arguments[0]
        }

        peers, err := api.PubSub().Peers(req.Context, options.PubSub.Topic(topic))
        if err != nil {
            return err
        }

        list := &stringList{make([]string, 0, len(peers))}

        for _, peer := range peers {
            list.Strings = append(list.Strings, peer.Pretty())
        }
        sort.Strings(list.Strings)
        return cmds.EmitOnce(res, list)
    },
    Type: stringList{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(stringListEncoder),
    },
}

var PubsubPubCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Publish a message to a given pubsub topic.",
        ShortDescription: "" /* 242 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("topic", true, false, "Topic to publish to."),
        cmds.StringArg("data", true, true, "Payload of message to publish.").EnableStdin(),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        topic := req.Arguments[0]

        err = req.ParseBodyArgs()
        if err != nil {
            return err
        }

        for _, data := range req.Arguments[1:] {
            if err := api.PubSub().Publish(req.Context, topic, []byte(data)); err != nil {
                return err
            }
        }

        return nil
    },
}

var PubsubSubCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Subscribe to messages on a given topic.",
        ShortDescription: "" /* 241 byte string literal not displayed */,

        LongDescription: "" /* 355 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("topic", true, false, "String name of topic to subscribe to."),
    },
    Options: []cmds.Option{
        cmds.BoolOption(pubsubDiscoverOptionName, "try to discover other peers subscribed to the same topic"),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        topic := req.Arguments[0]
        discover, _ := req.Options[pubsubDiscoverOptionName].(bool)

        sub, err := api.PubSub().Subscribe(req.Context, topic, options.PubSub.Discover(discover))
        if err != nil {
            return err
        }
        defer sub.Close()

        if f, ok := res.(http.Flusher); ok {
            f.Flush()
        }

        for {
            msg, err := sub.Next(req.Context)
            if err == io.EOF || err == context.Canceled {
                return nil
            } else if err != nil {
                return err
            }

            if err := res.Emit(&pubsubMessage{
                Data:     msg.Data(),
                From:     []byte(msg.From()),
                Seqno:    msg.Seq(),
                TopicIDs: msg.Topics(),
            }); err != nil {
                return err
            }
        }
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, psm *pubsubMessage) error {
            _, err := w.Write(psm.Data)
            return err
        }),
        "ndpayload": cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, psm *pubsubMessage) error {
            psm.Data = append(psm.Data, '\n')
            _, err := w.Write(psm.Data)
            return err
        }),
        "lenpayload": cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, psm *pubsubMessage) error {
            buf := make([]byte, 8, len(psm.Data)+8)

            n := binary.PutUvarint(buf, uint64(len(psm.Data)))
            buf = append(buf[:n], psm.Data...)
            _, err := w.Write(buf)
            return err
        }),
    },
    Type: pubsubMessage{},
}

var RefsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "List links (references) from an object.",
        ShortDescription: "" /* 185 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "local": RefsLocalCmd,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("ipfs-path", true, true, "Path to the object(s) to list refs from.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.StringOption(refsFormatOptionName, "Emit edges with given format. Available tokens: <src> <dst> <linkname>.").WithDefault("<dst>"),
        cmds.BoolOption(refsEdgesOptionName, "e", "Emit edge format: `<from> -> <to>`."),
        cmds.BoolOption(refsUniqueOptionName, "u", "Omit duplicate refs from output."),
        cmds.BoolOption(refsRecursiveOptionName, "r", "Recursively list links of child nodes."),
        cmds.IntOption(refsMaxDepthOptionName, "Only for recursive refs, limits fetch and listing to the given depth").WithDefault(-1),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        err := req.ParseBodyArgs()
        if err != nil {
            return err
        }

        ctx := req.Context
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        enc, err := cmdenv.GetCidEncoder(req)
        if err != nil {
            return err
        }

        unique, _ := req.Options[refsUniqueOptionName].(bool)
        recursive, _ := req.Options[refsRecursiveOptionName].(bool)
        maxDepth, _ := req.Options[refsMaxDepthOptionName].(int)
        edges, _ := req.Options[refsEdgesOptionName].(bool)
        format, _ := req.Options[refsFormatOptionName].(string)

        if !recursive {
            maxDepth = 1
        }

        if edges {
            if format != "<dst>" {
                return errors.New("using format argument with edges is not allowed")
            }

            format = "<src> -> <dst>"
        }

        objs, err := objectsForPaths(ctx, api, req.Arguments)
        if err != nil {
            return err
        }

        rw := RefWriter{
            res:      res,
            DAG:      api.Dag(),
            Ctx:      ctx,
            Unique:   unique,
            PrintFmt: format,
            MaxDepth: maxDepth,
        }

        for _, o := range objs {
            if _, err := rw.WriteRefs(o, enc); err != nil {
                if err := res.Emit(&RefWrapper{Err: err.Error()}); err != nil {
                    return err
                }
            }
        }

        return nil
    },
    Encoders: refsEncoderMap,
    Type:     RefWrapper{},
}

var RefsLocalCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "List all local references.",
        ShortDescription: `
Displays the hashes of all local objects.
`,
    },

    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        ctx := req.Context
        n, err := cmdenv.GetNode(env)
        if err != nil {
            return err
        }

        allKeys, err := n.Blockstore.AllKeysChan(ctx)
        if err != nil {
            return err
        }

        for k := range allKeys {
            err := res.Emit(&RefWrapper{Ref: k.String()})
            if err != nil {
                return err
            }
        }

        return nil
    },
    Encoders: refsEncoderMap,
    Type:     RefWrapper{},
}

var RefsROCmd = &cmds.Command{}

var RepoCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Manipulate the IPFS repo.",
        ShortDescription: `
'ipfs repo' is a plumbing command used to manipulate the repo.
`,
    },

    Subcommands: map[string]*cmds.Command{
        "stat":    repoStatCmd,
        "gc":      repoGcCmd,
        "fsck":    repoFsckCmd,
        "version": repoVersionCmd,
        "verify":  repoVerifyCmd,
    },
}

var ResolveCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Resolve the value of names to IPFS.",
        ShortDescription: "" /* 182 byte string literal not displayed */,

        LongDescription: "" /* 1015 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("name", true, false, "The name to resolve.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.BoolOption(resolveRecursiveOptionName, "r", "Resolve until the result is an IPFS name.").WithDefault(true),
        cmds.IntOption(resolveDhtRecordCountOptionName, "dhtrc", "Number of records to request for DHT resolution."),
        cmds.StringOption(resolveDhtTimeoutOptionName, "dhtt", "Max time to collect values during DHT resolution eg \"30s\". Pass 0 for no timeout."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        name := req.Arguments[0]
        recursive, _ := req.Options[resolveRecursiveOptionName].(bool)

        var enc cidenc.Encoder
        switch {
        case !cmdenv.CidBaseDefined(req):

            enc, err = cmdenv.CidEncoderFromPath(name)
            if err == nil {
                break
            }

            fallthrough
        default:
            enc, err = cmdenv.GetCidEncoder(req)
            if err != nil {
                return err
            }
        }

        if strings.HasPrefix(name, "/ipns/") && !recursive {
            rc, rcok := req.Options[resolveDhtRecordCountOptionName].(uint)
            dhtt, dhttok := req.Options[resolveDhtTimeoutOptionName].(string)
            ropts := []options.NameResolveOption{
                options.Name.ResolveOption(nsopts.Depth(1)),
            }

            if rcok {
                ropts = append(ropts, options.Name.ResolveOption(nsopts.DhtRecordCount(rc)))
            }
            if dhttok {
                d, err := time.ParseDuration(dhtt)
                if err != nil {
                    return err
                }
                if d < 0 {
                    return errors.New("DHT timeout value must be >= 0")
                }
                ropts = append(ropts, options.Name.ResolveOption(nsopts.DhtTimeout(d)))
            }
            p, err := api.Name().Resolve(req.Context, name, ropts...)

            if err != nil && err != ns.ErrResolveRecursion {
                return err
            }
            return cmds.EmitOnce(res, &ncmd.ResolvedPath{Path: ipfspath.Path(p.String())})
        }

        rp, err := api.ResolvePath(req.Context, path.New(name))
        if err != nil {
            return err
        }

        encoded := "/" + rp.Namespace() + "/" + enc.Encode(rp.Cid())
        if remainder := rp.Remainder(); remainder != "" {
            encoded += "/" + remainder
        }

        return cmds.EmitOnce(res, &ncmd.ResolvedPath{Path: ipfspath.Path(encoded)})
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, rp *ncmd.ResolvedPath) error {
            fmt.Fprintln(w, rp.Path.String())
            return nil
        }),
    },
    Type: ncmd.ResolvedPath{},
}

var Root = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:     "Global p2p merkle-dag filesystem.",
        Synopsis:    "" /* 202 byte string literal not displayed */,
        Subcommands: "" /* 2040 byte string literal not displayed */,
    },
    Options: []cmds.Option{
        cmds.StringOption(ConfigOption, "c", "Path to the configuration file to use."),
        cmds.BoolOption(DebugOption, "D", "Operate in debug mode."),
        cmds.BoolOption(cmds.OptLongHelp, "Show the full command help text."),
        cmds.BoolOption(cmds.OptShortHelp, "Show a short version of the command help text."),
        cmds.BoolOption(LocalOption, "L", "Run the command locally, instead of using the daemon. DEPRECATED: use --offline."),
        cmds.BoolOption(OfflineOption, "Run the command offline."),
        cmds.StringOption(ApiOption, "Use a specific API instance (defaults to /ip4/127.0.0.1/tcp/5001)"),

        cmdenv.OptionCidBase,
        cmdenv.OptionUpgradeCidV0InOutput,

        cmds.OptionEncodingType,
        cmds.OptionStreamChannels,
        cmds.OptionTimeout,
    },
}

var RootRO = &cmds.Command{}

var StatsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Query IPFS statistics.",
        ShortDescription: `'ipfs stats' is a set of commands to help look at statistics
for your IPFS node.
`,
        LongDescription: `'ipfs stats' is a set of commands to help look at statistics
for your IPFS node.`,
    },

    Subcommands: map[string]*cmds.Command{
        "bw":      statBwCmd,
        "repo":    repoStatCmd,
        "bitswap": bitswapStatCmd,
    },
}

var SwarmCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with the swarm.",
        ShortDescription: "" /* 174 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "addrs":      swarmAddrsCmd,
        "connect":    swarmConnectCmd,
        "disconnect": swarmDisconnectCmd,
        "filters":    swarmFiltersCmd,
        "peers":      swarmPeersCmd,
    },
}

var TarCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Utility functions for tar files in ipfs.",
    },

    Subcommands: map[string]*cmds.Command{
        "add": tarAddCmd,
        "cat": tarCatCmd,
    },
}

var VersionCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Show ipfs version information.",
        ShortDescription: "Returns the current version of ipfs and exits.",
    },
    Subcommands: map[string]*cmds.Command{
        "deps": depsVersionCommand,
    },

    Options: []cmds.Option{
        cmds.BoolOption(versionNumberOptionName, "n", "Only show the version number."),
        cmds.BoolOption(versionCommitOptionName, "Show the commit hash."),
        cmds.BoolOption(versionRepoOptionName, "Show repo version."),
        cmds.BoolOption(versionAllOptionName, "Show all version information"),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        return cmds.EmitOnce(res, &VersionOutput{
            Version: version.CurrentVersionNumber,
            Commit:  version.CurrentCommit,
            Repo:    fmt.Sprint(fsrepo.RepoVersion),
            System:  runtime.GOARCH + "/" + runtime.GOOS,
            Golang:  runtime.Version(),
        })
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, version *VersionOutput) error {
            all, _ := req.Options[versionAllOptionName].(bool)
            if all {
                ver := version.Version
                if version.Commit != "" {
                    ver += "-" + version.Commit
                }
                out := fmt.Sprintf("go-ipfs version: %s\n"+
                    "Repo version: %s\nSystem version: %s\nGolang version: %s\n",
                    ver, version.Repo, version.System, version.Golang)
                fmt.Fprint(w, out)
                return nil
            }

            commit, _ := req.Options[versionCommitOptionName].(bool)
            commitTxt := ""
            if commit && version.Commit != "" {
                commitTxt = "-" + version.Commit
            }

            repo, _ := req.Options[versionRepoOptionName].(bool)
            if repo {
                fmt.Fprintln(w, version.Repo)
                return nil
            }

            number, _ := req.Options[versionNumberOptionName].(bool)
            if number {
                fmt.Fprintln(w, version.Version+commitTxt)
                return nil
            }

            fmt.Fprint(w, fmt.Sprintf("ipfs version %s%s\n", version.Version, commitTxt))
            return nil
        }),
    },
    Type: VersionOutput{},
}

var VersionROCmd = &cmds.Command{}

type AddEvent struct {
    Name  string
    Hash  string `json:",omitempty"`
    Bytes int64  `json:",omitempty"`
    Size  string `json:",omitempty"`
}

type AddPinOutput struct {
    Pins     []string
    Progress int `json:",omitempty"`
}

type BadNode struct {
    Cid string
    Err string
}

type BlockStat struct {
    Key  string
    Size int
}

type BootstrapOutput struct {
    Peers []string
}

type CidFormatRes struct {
    CidStr    string // Original Cid String passed in
    Formatted string // Formated Result
    ErrorMsg  string // Error
}

type CodeAndName struct {
    Code int
    Name string
}

type Command struct {
    Name        string
    Subcommands []Command
    Options     []Option
    // contains filtered or unexported fields
}

type ConfigField struct {
    Key   string
    Value interface{}
}

type ConfigUpdateOutput struct {
    OldCfg map[string]interface{}
    NewCfg map[string]interface{}
}

type Dependency struct {
    Path       string
    Version    string
    ReplacedBy string
    Sum        string
}

type GcResult struct {
    Key   cid.Cid
    Error string `json:",omitempty"`
}

type IdOutput struct {
    ID              string
    PublicKey       string
    Addresses       []string
    AgentVersion    string
    ProtocolVersion string
}

type KeyList struct {
    Keys []cid.Cid
}

type KeyOutput struct {
    Name string
    Id   string
}

type KeyOutputList struct {
    Keys []KeyOutput
}

type KeyRenameOutput struct {
    Was       string
    Now       string
    Id        string
    Overwrite bool
}

type LsLink struct {
    Name, Hash string
    Size       uint64
    Type       unixfs_pb.Data_DataType
    Target     string
}

type LsObject struct {
    Hash  string
    Links []LsLink
}

type LsOutput struct {
    Objects []LsObject
}

type MessageOutput struct {
    Message string
}

type Option struct {
    Names []string
}

type P2PListenerInfoOutput struct {
    Protocol      string
    ListenAddress string
    TargetAddress string
}

type P2PLsOutput struct {
    Listeners []P2PListenerInfoOutput
}

type P2PStreamInfoOutput struct {
    HandlerID     string
    Protocol      string
    OriginAddress string
    TargetAddress string
}

type P2PStreamsOutput struct {
    Streams []P2PStreamInfoOutput
}

type PinLsList struct {
    Keys map[string]PinLsType
}

type PinLsObject struct {
    Cid  string `json:",omitempty"`
    Type string `json:",omitempty"`
}

type PinLsOutputWrapper struct {
    PinLsList
    PinLsObject
}

type PinLsType struct {
    Type string
}

type PinOutput struct {
    Pins []string
}

type PinStatus struct {
    Ok       bool
    BadNodes []BadNode `json:",omitempty"`
}

type PinVerifyRes struct {
    Cid string
    PinStatus
}

type PingResult struct {
    Success bool
    Time    time.Duration
    Text    string
}

type RefWrapper struct {
    Ref string
    Err string
}

type RefWriter struct {
    DAG ipld.DAGService
    Ctx context.Context

    Unique   bool
    MaxDepth int
    PrintFmt string
    // contains filtered or unexported fields
}

type RepoVersion struct {
    Version string
}

type VerifyProgress struct {
    Msg      string
    Progress int
}

type VersionOutput struct {
    Version string
    Commit  string
    Repo    string
    System  string
    Golang  string
}