├── scripts ├── build.sh ├── release.sh └── test.sh ├── .gitignore ├── config └── default_repos.yaml ├── tests ├── fixtures │ ├── tools.json │ └── config.sample.yaml ├── integration │ ├── cli_test.go │ ├── install_test.go │ └── uninstall_test.go └── unit │ └── repository_test.go ├── pkg ├── utils │ ├── hash.go │ ├── version.go │ └── compression.go ├── manifest │ └── schema.go ├── installer │ ├── installer.go │ └── steps.go └── repository │ ├── types.go │ └── client.go ├── api ├── handlers │ ├── system.go │ ├── tools.go │ └── repositories.go └── server │ └── server.go ├── internal ├── cli │ ├── cmd │ │ ├── api.go │ │ ├── install.go │ │ ├── list.go │ │ ├── repo.go │ │ ├── search.go │ │ ├── update.go │ │ ├── uninstall.go │ │ ├── root.go │ │ └── simulate.go │ └── ui │ │ ├── colors.go │ │ ├── progress.go │ │ └── prompt.go ├── utils │ ├── logging.go │ ├── network.go │ └── filesystem.go ├── config │ ├── config.go │ └── defaults.go ├── handlers │ ├── update.go │ ├── install.go │ ├── repository.go │ └── uninstall.go └── core │ ├── integrity │ ├── signature.go │ ├── checksum.go │ └── verifier.go │ ├── platform │ ├── darwin.go │ ├── linux.go │ ├── detector.go │ └── windows.go │ ├── dependency │ ├── checker.go │ ├── graph.go │ └── resolver.go │ ├── repository │ └── repository.go │ └── manifest │ └── types.go ├── vendor ├── github.com │ ├── kevinburke │ │ └── ssh_config │ │ │ ├── .gitignore │ │ │ ├── .gitattributes │ │ │ ├── .mailmap │ │ │ ├── AUTHORS.txt │ │ │ ├── CHANGELOG.md │ │ │ ├── position.go │ │ │ ├── Makefile │ │ │ └── token.go │ ├── go-git │ │ ├── gcfg │ │ │ ├── .gitignore │ │ │ ├── types │ │ │ │ ├── doc.go │ │ │ │ ├── bool.go │ │ │ │ └── scan.go │ │ │ ├── README │ │ │ ├── Makefile │ │ │ └── errors.go │ │ ├── go-billy │ │ │ └── v5 │ │ │ │ ├── .gitignore │ │ │ │ ├── osfs │ │ │ │ ├── os_options.go │ │ │ │ ├── os_js.go │ │ │ │ ├── os_wasip1.go │ │ │ │ └── os_posix.go │ │ │ │ └── Makefile │ │ └── go-git │ │ │ └── v5 │ │ │ ├── .gitignore │ │ │ ├── plumbing │ │ │ ├── format │ │ │ │ ├── objfile │ │ │ │ │ └── doc.go │ │ │ │ ├── packfile │ │ │ │ │ └── error.go │ │ │ │ ├── config │ │ │ │ │ └── decoder.go │ │ │ │ └── gitignore │ │ │ │ │ └── matcher.go │ │ │ ├── storer │ │ │ │ ├── doc.go │ │ │ │ ├── index.go │ │ │ │ ├── shallow.go │ │ │ │ └── storer.go │ │ │ ├── revision.go │ │ │ ├── hash │ │ │ │ ├── hash_sha1.go │ │ │ │ └── hash_sha256.go │ │ │ ├── error.go │ │ │ ├── protocol │ │ │ │ └── packp │ │ │ │ │ └── sideband │ │ │ │ │ └── common.go │ │ │ └── transport │ │ │ │ ├── http │ │ │ │ └── transport.go │ │ │ │ └── internal │ │ │ │ └── common │ │ │ │ └── mocks.go │ │ │ ├── internal │ │ │ ├── revision │ │ │ │ └── token.go │ │ │ └── path_util │ │ │ │ └── path_util.go │ │ │ ├── doc.go │ │ │ ├── storage │ │ │ ├── filesystem │ │ │ │ ├── module.go │ │ │ │ ├── deltaobject.go │ │ │ │ └── config.go │ │ │ └── storer.go │ │ │ ├── common.go │ │ │ ├── worktree_js.go │ │ │ ├── worktree_bsd.go │ │ │ ├── worktree_linux.go │ │ │ ├── worktree_unix_other.go │ │ │ ├── worktree_plan9.go │ │ │ ├── utils │ │ │ └── sync │ │ │ │ └── bufio.go │ │ │ ├── worktree_windows.go │ │ │ └── signer.go │ ├── spf13 │ │ ├── pflag │ │ │ ├── .gitignore │ │ │ ├── .golangci.yaml │ │ │ ├── .editorconfig │ │ │ └── .travis.yml │ │ └── cobra │ │ │ ├── .mailmap │ │ │ ├── MAINTAINERS │ │ │ ├── .gitignore │ │ │ ├── command_notwin.go │ │ │ └── Makefile │ ├── cyphar │ │ └── filepath-securejoin │ │ │ ├── VERSION │ │ │ ├── gocompat_errors_go120.go │ │ │ ├── gocompat_generics_go121.go │ │ │ └── gocompat_errors_unsupported.go │ ├── Microsoft │ │ └── go-winio │ │ │ ├── .gitattributes │ │ │ ├── CODEOWNERS │ │ │ ├── internal │ │ │ ├── fs │ │ │ │ ├── doc.go │ │ │ │ └── security.go │ │ │ └── socket │ │ │ │ └── rawaddr.go │ │ │ ├── .gitignore │ │ │ ├── syscall.go │ │ │ └── pkg │ │ │ └── guid │ │ │ ├── guid_windows.go │ │ │ ├── guid_nonwindows.go │ │ │ └── variant_string.go │ ├── mattn │ │ ├── go-isatty │ │ │ ├── doc.go │ │ │ ├── go.test.sh │ │ │ ├── isatty_others.go │ │ │ ├── isatty_plan9.go │ │ │ ├── isatty_tcgets.go │ │ │ ├── isatty_solaris.go │ │ │ ├── isatty_bsd.go │ │ │ └── LICENSE │ │ └── go-colorable │ │ │ ├── go.test.sh │ │ │ ├── colorable_appengine.go │ │ │ └── colorable_others.go │ ├── ProtonMail │ │ └── go-crypto │ │ │ ├── openpgp │ │ │ ├── packet │ │ │ │ ├── config_v5.go │ │ │ │ ├── recipient.go │ │ │ │ ├── packet_unsupported.go │ │ │ │ ├── notation.go │ │ │ │ ├── padding.go │ │ │ │ └── marker.go │ │ │ ├── hash.go │ │ │ ├── internal │ │ │ │ └── encoding │ │ │ │ │ └── encoding.go │ │ │ └── s2k │ │ │ │ └── s2k_cache.go │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ └── ocb │ │ │ └── rfc7253_test_vectors_suite_b.go │ ├── cloudflare │ │ └── circl │ │ │ ├── sign │ │ │ └── ed25519 │ │ │ │ ├── pubkey112.go │ │ │ │ └── pubkey.go │ │ │ ├── dh │ │ │ ├── x448 │ │ │ │ ├── curve_noasm.go │ │ │ │ ├── curve_amd64.go │ │ │ │ └── doc.go │ │ │ └── x25519 │ │ │ │ ├── curve_noasm.go │ │ │ │ ├── curve_amd64.go │ │ │ │ └── doc.go │ │ │ ├── math │ │ │ ├── integer.go │ │ │ ├── fp448 │ │ │ │ ├── fp_noasm.go │ │ │ │ └── fp_amd64.go │ │ │ ├── fp25519 │ │ │ │ └── fp_noasm.go │ │ │ └── primes.go │ │ │ └── internal │ │ │ └── sha3 │ │ │ ├── xor.go │ │ │ ├── rc.go │ │ │ ├── xor_generic.go │ │ │ └── sha3_s390x.s │ ├── pjbgf │ │ └── sha1cd │ │ │ ├── sha1cdblock_noasm.go │ │ │ ├── ubc │ │ │ ├── ubc.go │ │ │ ├── ubc_noasm.go │ │ │ └── ubc_amd64.go │ │ │ ├── detection.go │ │ │ ├── Dockerfile.arm │ │ │ ├── Dockerfile.arm64 │ │ │ └── Makefile │ ├── stretchr │ │ └── testify │ │ │ └── assert │ │ │ ├── assertion_format.go.tmpl │ │ │ ├── assertion_forward.go.tmpl │ │ │ ├── errors.go │ │ │ ├── forward_assertions.go │ │ │ └── yaml │ │ │ ├── yaml_fail.go │ │ │ └── yaml_custom.go │ ├── xanzy │ │ └── ssh-agent │ │ │ └── .gitignore │ ├── sergi │ │ └── go-diff │ │ │ ├── diffmatchpatch │ │ │ ├── operation_string.go │ │ │ └── mathutil.go │ │ │ └── AUTHORS │ ├── inconshreveable │ │ └── mousetrap │ │ │ ├── trap_others.go │ │ │ └── README.md │ ├── fatih │ │ └── color │ │ │ └── color_windows.go │ ├── skeema │ │ └── knownhosts │ │ │ └── NOTICE │ ├── emirpasic │ │ └── gods │ │ │ ├── containers │ │ │ └── serialization.go │ │ │ ├── trees │ │ │ ├── trees.go │ │ │ └── binaryheap │ │ │ │ └── serialization.go │ │ │ └── utils │ │ │ └── sort.go │ └── davecgh │ │ └── go-spew │ │ └── LICENSE ├── golang.org │ └── x │ │ ├── sys │ │ ├── unix │ │ │ ├── .gitignore │ │ │ ├── ptrace_ios.go │ │ │ ├── vgetrandom_unsupported.go │ │ │ ├── syscall_linux_amd64_gc.go │ │ │ ├── endian_big.go │ │ │ ├── ptrace_darwin.go │ │ │ ├── constants.go │ │ │ ├── endian_little.go │ │ │ ├── mmap_nomremap.go │ │ │ ├── vgetrandom_linux.go │ │ │ ├── auxv_unsupported.go │ │ │ ├── aliases.go │ │ │ ├── readdirent_getdents.go │ │ │ ├── pagesize_unix.go │ │ │ ├── sysvshm_unix_other.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── syscall_linux_gc_arm.go │ │ │ ├── asm_solaris_amd64.s │ │ │ ├── fcntl_linux_32bit.go │ │ │ ├── syscall_linux_alarm.go │ │ │ ├── gccgo_linux_amd64.go │ │ │ ├── syscall_linux_gc.go │ │ │ ├── syscall_hurd_386.go │ │ │ ├── sysvshm_linux.go │ │ │ ├── sockcmsg_dragonfly.go │ │ │ ├── race0.go │ │ │ ├── syscall_linux_gc_386.go │ │ │ ├── syscall_linux_gccgo_arm.go │ │ │ ├── syscall_unix_gc.go │ │ │ ├── syscall_solaris_amd64.go │ │ │ ├── race.go │ │ │ ├── env_unix.go │ │ │ ├── syscall_hurd.go │ │ │ ├── asm_bsd_arm.s │ │ │ ├── readdirent_getdirentries.go │ │ │ ├── zptrace_linux_arm64.go │ │ │ ├── asm_openbsd_mips64.s │ │ │ ├── asm_bsd_386.s │ │ │ ├── asm_bsd_arm64.s │ │ │ ├── asm_bsd_riscv64.s │ │ │ ├── asm_bsd_amd64.s │ │ │ ├── asm_bsd_ppc64.s │ │ │ ├── bluetooth_linux.go │ │ │ ├── dev_aix_ppc.go │ │ │ ├── dev_darwin.go │ │ │ ├── syscall_unix_gc_ppc64x.go │ │ │ ├── fdset.go │ │ │ ├── fcntl_darwin.go │ │ │ ├── dev_zos.go │ │ │ ├── dev_aix_ppc64.go │ │ │ ├── syscall_netbsd_amd64.go │ │ │ ├── syscall_netbsd_arm64.go │ │ │ ├── syscall_netbsd_386.go │ │ │ ├── syscall_netbsd_arm.go │ │ │ ├── dev_netbsd.go │ │ │ ├── dev_openbsd.go │ │ │ └── asm_linux_ppc64x.s │ │ ├── cpu │ │ │ ├── cpu_other_arm.go │ │ │ ├── cpu_zos.go │ │ │ ├── cpu_other_arm64.go │ │ │ ├── cpu_mipsx.go │ │ │ ├── cpu_other_riscv64.go │ │ │ ├── cpu_other_mips64x.go │ │ │ ├── cpu_gc_arm64.go │ │ │ ├── cpu_other_ppc64x.go │ │ │ ├── cpu_gccgo_arm64.go │ │ │ ├── cpu_linux_noinit.go │ │ │ ├── cpu_other_x86.go │ │ │ ├── cpu_linux.go │ │ │ ├── cpu_mips64x.go │ │ │ ├── cpu_loong64.s │ │ │ ├── cpu_openbsd_arm64.s │ │ │ ├── cpu_ppc64x.go │ │ │ ├── endian_big.go │ │ │ ├── runtime_auxv_go121.go │ │ │ ├── runtime_auxv.go │ │ │ ├── endian_little.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── cpu_wasm.go │ │ │ ├── cpu_gc_x86.go │ │ │ ├── cpu_linux_mips64x.go │ │ │ ├── cpu_riscv64.go │ │ │ ├── asm_darwin_x86_gc.s │ │ │ ├── cpu_gc_x86.s │ │ │ ├── cpu_linux_loong64.go │ │ │ ├── cpu_gccgo_x86.go │ │ │ ├── cpu_aix.go │ │ │ ├── cpu_zos_s390x.go │ │ │ ├── cpu_gc_s390x.go │ │ │ ├── syscall_aix_gccgo.go │ │ │ ├── cpu_linux_ppc64x.go │ │ │ ├── cpu_linux_s390x.go │ │ │ ├── cpu_arm64.s │ │ │ └── cpu_gccgo_s390x.go │ │ ├── windows │ │ │ ├── aliases.go │ │ │ ├── mksyscall.go │ │ │ ├── race0.go │ │ │ ├── str.go │ │ │ ├── race.go │ │ │ ├── eventlog.go │ │ │ ├── types_windows_amd64.go │ │ │ ├── types_windows_arm64.go │ │ │ ├── types_windows_386.go │ │ │ └── types_windows_arm.go │ │ └── execabs │ │ │ ├── execabs_go118.go │ │ │ └── execabs_go119.go │ │ ├── crypto │ │ ├── internal │ │ │ └── poly1305 │ │ │ │ └── mac_noasm.go │ │ ├── sha3 │ │ │ ├── keccakf_amd64.go │ │ │ ├── shake_noasm.go │ │ │ ├── hashes_noasm.go │ │ │ └── sha3_s390x.s │ │ ├── blake2b │ │ │ ├── blake2b_ref.go │ │ │ ├── register.go │ │ │ └── blake2bAVX2_amd64.go │ │ ├── chacha20 │ │ │ ├── chacha_noasm.go │ │ │ ├── chacha_arm64.go │ │ │ ├── chacha_ppc64x.go │ │ │ └── chacha_s390x.go │ │ ├── argon2 │ │ │ └── blamka_ref.go │ │ └── ssh │ │ │ └── doc.go │ │ └── net │ │ └── proxy │ │ └── direct.go ├── dario.cat │ └── mergo │ │ ├── .deepsource.toml │ │ ├── .travis.yml │ │ ├── SECURITY.md │ │ └── .gitignore └── gopkg.in │ └── yaml.v3 │ └── NOTICE ├── README.md ├── .github ├── ISSUE_TEMPLATE │ ├── custom.md │ ├── feature_request.md │ └── bug_report.md └── workflows │ ├── build.yml │ ├── test.yml │ └── release.yml ├── cmd └── fleet │ └── main.go └── CONTRIBUTING.md /scripts/build.sh: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /scripts/release.sh: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /scripts/test.sh: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | -------------------------------------------------------------------------------- /config/default_repos.yaml: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/fixtures/tools.json: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/fixtures/config.sample.yaml: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /pkg/utils/hash.go: -------------------------------------------------------------------------------- 1 | package utils 2 | -------------------------------------------------------------------------------- /pkg/utils/version.go: -------------------------------------------------------------------------------- 1 | package utils 2 | -------------------------------------------------------------------------------- /api/handlers/system.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | -------------------------------------------------------------------------------- /api/handlers/tools.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | -------------------------------------------------------------------------------- /api/server/server.go: -------------------------------------------------------------------------------- 1 | package server 2 | -------------------------------------------------------------------------------- /internal/cli/cmd/api.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | -------------------------------------------------------------------------------- /internal/cli/cmd/install.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | -------------------------------------------------------------------------------- /internal/cli/cmd/list.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | -------------------------------------------------------------------------------- /internal/cli/cmd/repo.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | -------------------------------------------------------------------------------- /internal/cli/cmd/search.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | -------------------------------------------------------------------------------- /internal/cli/cmd/update.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | -------------------------------------------------------------------------------- /internal/cli/ui/colors.go: -------------------------------------------------------------------------------- 1 | package ui 2 | -------------------------------------------------------------------------------- /internal/cli/ui/progress.go: -------------------------------------------------------------------------------- 1 | package ui 2 | -------------------------------------------------------------------------------- /internal/cli/ui/prompt.go: -------------------------------------------------------------------------------- 1 | package ui 2 | -------------------------------------------------------------------------------- /internal/utils/logging.go: -------------------------------------------------------------------------------- 1 | package utils 2 | -------------------------------------------------------------------------------- /internal/utils/network.go: -------------------------------------------------------------------------------- 1 | package utils 2 | -------------------------------------------------------------------------------- /pkg/manifest/schema.go: -------------------------------------------------------------------------------- 1 | package manifest 2 | -------------------------------------------------------------------------------- /pkg/utils/compression.go: -------------------------------------------------------------------------------- 1 | package utils 2 | -------------------------------------------------------------------------------- /internal/cli/cmd/uninstall.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | -------------------------------------------------------------------------------- /internal/config/config.go: -------------------------------------------------------------------------------- 1 | package config 2 | -------------------------------------------------------------------------------- /internal/config/defaults.go: -------------------------------------------------------------------------------- 1 | package config 2 | -------------------------------------------------------------------------------- /internal/handlers/update.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | -------------------------------------------------------------------------------- /internal/utils/filesystem.go: -------------------------------------------------------------------------------- 1 | package utils 2 | -------------------------------------------------------------------------------- /pkg/installer/installer.go: -------------------------------------------------------------------------------- 1 | package installer 2 | -------------------------------------------------------------------------------- /pkg/installer/steps.go: -------------------------------------------------------------------------------- 1 | package installer 2 | -------------------------------------------------------------------------------- /api/handlers/repositories.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | -------------------------------------------------------------------------------- /internal/core/integrity/signature.go: -------------------------------------------------------------------------------- 1 | package integrity -------------------------------------------------------------------------------- /internal/core/platform/darwin.go: -------------------------------------------------------------------------------- 1 | package platform 2 | -------------------------------------------------------------------------------- /internal/core/platform/linux.go: -------------------------------------------------------------------------------- 1 | package platform 2 | -------------------------------------------------------------------------------- /internal/handlers/install.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | -------------------------------------------------------------------------------- /internal/handlers/repository.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | -------------------------------------------------------------------------------- /internal/handlers/uninstall.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | -------------------------------------------------------------------------------- /tests/integration/cli_test.go: -------------------------------------------------------------------------------- 1 | package integration 2 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/.gitignore: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /internal/core/dependency/checker.go: -------------------------------------------------------------------------------- 1 | package dependency 2 | -------------------------------------------------------------------------------- /internal/core/dependency/graph.go: -------------------------------------------------------------------------------- 1 | package dependency 2 | -------------------------------------------------------------------------------- /internal/core/integrity/checksum.go: -------------------------------------------------------------------------------- 1 | package integrity 2 | -------------------------------------------------------------------------------- /internal/core/integrity/verifier.go: -------------------------------------------------------------------------------- 1 | package integrity 2 | -------------------------------------------------------------------------------- /internal/core/platform/detector.go: -------------------------------------------------------------------------------- 1 | package platform 2 | -------------------------------------------------------------------------------- /internal/core/platform/windows.go: -------------------------------------------------------------------------------- 1 | package platform 2 | -------------------------------------------------------------------------------- /tests/integration/install_test.go: -------------------------------------------------------------------------------- 1 | package integration 2 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/.gitignore: -------------------------------------------------------------------------------- 1 | coverage.out 2 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/pflag/.gitignore: -------------------------------------------------------------------------------- 1 | .idea/* 2 | 3 | -------------------------------------------------------------------------------- /internal/core/dependency/resolver.go: -------------------------------------------------------------------------------- 1 | package dependency 2 | -------------------------------------------------------------------------------- /tests/integration/uninstall_test.go: -------------------------------------------------------------------------------- 1 | package integration 2 | -------------------------------------------------------------------------------- /vendor/github.com/cyphar/filepath-securejoin/VERSION: -------------------------------------------------------------------------------- 1 | 0.4.1 2 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/.gitignore: -------------------------------------------------------------------------------- 1 | _obj/ 2 | unix.test 3 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/.gitattributes: -------------------------------------------------------------------------------- 1 | * text=auto eol=lf -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/CODEOWNERS: -------------------------------------------------------------------------------- 1 | * @microsoft/containerplat 2 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/.gitattributes: -------------------------------------------------------------------------------- 1 | testdata/dos-lines eol=crlf 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/DiegoDev2/Fleet) 2 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/.gitignore: -------------------------------------------------------------------------------- 1 | /coverage.txt 2 | /vendor 3 | Gopkg.lock 4 | Gopkg.toml 5 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/osfs/os_options.go: -------------------------------------------------------------------------------- 1 | package osfs 2 | 3 | type Option func(*options) 4 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/.mailmap: -------------------------------------------------------------------------------- 1 | Kevin Burke Kevin Burke 2 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/doc.go: -------------------------------------------------------------------------------- 1 | // Package isatty implements interface to isatty 2 | package isatty 3 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/pflag/.golangci.yaml: -------------------------------------------------------------------------------- 1 | linters: 2 | disable-all: true 3 | enable: 4 | - nolintlint 5 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/internal/fs/doc.go: -------------------------------------------------------------------------------- 1 | // This package contains Win32 filesystem functionality. 2 | package fs 3 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/.gitignore: -------------------------------------------------------------------------------- 1 | coverage.out 2 | *~ 3 | coverage.txt 4 | profile.out 5 | .tmp/ 6 | .git-dist/ 7 | .vscode 8 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/format/objfile/doc.go: -------------------------------------------------------------------------------- 1 | // Package objfile implements encoding and decoding of object files. 2 | package objfile 3 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/storer/doc.go: -------------------------------------------------------------------------------- 1 | // Package storer defines the interfaces to store objects, references, etc. 2 | package storer 3 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/packet/config_v5.go: -------------------------------------------------------------------------------- 1 | //go:build !v5 2 | 3 | package packet 4 | 5 | func init() { 6 | V5Disabled = true 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/.gitignore: -------------------------------------------------------------------------------- 1 | .vscode/ 2 | 3 | *.exe 4 | 5 | # testing 6 | testdata 7 | 8 | # go workspaces 9 | go.work 10 | go.work.sum 11 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/types/doc.go: -------------------------------------------------------------------------------- 1 | // Package types defines helpers for type conversions. 2 | // 3 | // The API for this package is not finalized yet. 4 | package types 5 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/syscall.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | 3 | package winio 4 | 5 | //go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go ./*.go 6 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/README: -------------------------------------------------------------------------------- 1 | Gcfg reads INI-style configuration files into Go structs; 2 | supports user-defined types and subsections. 3 | 4 | Package docs: https://godoc.org/gopkg.in/gcfg.v1 5 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/custom.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Custom issue template 3 | about: Describe this issue template's purpose here. 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | 11 | -------------------------------------------------------------------------------- /cmd/fleet/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "github.com/DiegoDev2/Fleet/internal/cli/cmd" 5 | ) 6 | 7 | func main() { 8 | if err := cmd.Execute(); err != nil { 9 | panic(err) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/sign/ed25519/pubkey112.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.13 2 | // +build !go1.13 3 | 4 | package ed25519 5 | 6 | // PublicKey is the type of Ed25519 public keys. 7 | type PublicKey []byte 8 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/sha1cdblock_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || noasm || !gc 2 | // +build !amd64 noasm !gc 3 | 4 | package sha1cd 5 | 6 | func block(dig *digest, p []byte) { 7 | blockGeneric(dig, p) 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/.mailmap: -------------------------------------------------------------------------------- 1 | Steve Francia 2 | Bjørn Erik Pedersen 3 | Fabiano Franz 4 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at https://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/dario.cat/mergo/.deepsource.toml: -------------------------------------------------------------------------------- 1 | version = 1 2 | 3 | test_patterns = [ 4 | "*_test.go" 5 | ] 6 | 7 | [[analyzers]] 8 | name = "go" 9 | enabled = true 10 | 11 | [analyzers.meta] 12 | import_path = "dario.cat/mergo" -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at https://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/MAINTAINERS: -------------------------------------------------------------------------------- 1 | maintainers: 2 | - spf13 3 | - johnSchnake 4 | - jpmcb 5 | - marckhouzam 6 | inactive: 7 | - anthonyfok 8 | - bep 9 | - bogem 10 | - broady 11 | - eparis 12 | - jharshman 13 | - wfernandes 14 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentFormat}} 2 | func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool { 3 | if h, ok := t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}}) 5 | } 6 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentWithoutT "a"}} 2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool { 3 | if h, ok := a.t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) 5 | } 6 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/ubc/ubc.go: -------------------------------------------------------------------------------- 1 | // ubc package provides ways for SHA1 blocks to be checked for 2 | // Unavoidable Bit Conditions that arise from crypto analysis attacks. 3 | package ubc 4 | 5 | //go:generate go run -C asm . -out ../ubc_amd64.s -pkg $GOPACKAGE 6 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/pflag/.editorconfig: -------------------------------------------------------------------------------- 1 | root = true 2 | 3 | [*] 4 | charset = utf-8 5 | end_of_line = lf 6 | indent_size = 4 7 | indent_style = space 8 | insert_final_newline = true 9 | trim_trailing_whitespace = true 10 | 11 | [*.go] 12 | indent_style = tab 13 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/sign/ed25519/pubkey.go: -------------------------------------------------------------------------------- 1 | //go:build go1.13 2 | // +build go1.13 3 | 4 | package ed25519 5 | 6 | import cryptoEd25519 "crypto/ed25519" 7 | 8 | // PublicKey is the type of Ed25519 public keys. 9 | type PublicKey cryptoEd25519.PublicKey 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux && arm 6 | 7 | package cpu 8 | 9 | func archInit() {} 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_zos.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | func archInit() { 8 | doinit() 9 | Initialized = true 10 | } 11 | -------------------------------------------------------------------------------- /pkg/repository/types.go: -------------------------------------------------------------------------------- 1 | package repository 2 | 3 | import "time" 4 | 5 | type RepoInfo struct { 6 | Name string `json:"name"` 7 | URL string `json:"url"` 8 | Type string `json:"type"` 9 | Priority int `json:"priority"` 10 | LastSync time.Time `json:"last_sync"` 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/storer/index.go: -------------------------------------------------------------------------------- 1 | package storer 2 | 3 | import "github.com/go-git/go-git/v5/plumbing/format/index" 4 | 5 | // IndexStorer generic storage of index.Index 6 | type IndexStorer interface { 7 | SetIndex(*index.Index) error 8 | Index() (*index.Index, error) 9 | } 10 | -------------------------------------------------------------------------------- /pkg/repository/client.go: -------------------------------------------------------------------------------- 1 | package repository 2 | 3 | // Client define la interfaz para un cliente de repositorio 4 | type Client interface { 5 | // Sync sincroniza el repositorio con la fuente remota 6 | Sync() error 7 | 8 | // GetInfo devuelve información básica sobre el repositorio 9 | GetInfo() RepoInfo 10 | } 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux && !netbsd && !openbsd && arm64 6 | 7 | package cpu 8 | 9 | func doinit() {} 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_mipsx.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build mips || mipsle 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 32 10 | 11 | func initOptions() {} 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux && riscv64 6 | 7 | package cpu 8 | 9 | func archInit() { 10 | Initialized = true 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux && (mips64 || mips64le) 6 | 7 | package cpu 8 | 9 | func archInit() { 10 | Initialized = true 11 | } 12 | -------------------------------------------------------------------------------- /vendor/dario.cat/mergo/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | arch: 3 | - amd64 4 | - ppc64le 5 | install: 6 | - go get -t 7 | - go get golang.org/x/tools/cmd/cover 8 | - go get github.com/mattn/goveralls 9 | script: 10 | - go test -race -v ./... 11 | after_script: 12 | - $HOME/gopath/bin/goveralls -service=travis-ci -repotoken $COVERALLS_TOKEN 13 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/go.test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | echo "" > coverage.txt 5 | 6 | for d in $(go list ./... | grep -v vendor); do 7 | go test -race -coverprofile=profile.out -covermode=atomic "$d" 8 | if [ -f profile.out ]; then 9 | cat profile.out >> coverage.txt 10 | rm profile.out 11 | fi 12 | done 13 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/go.test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | echo "" > coverage.txt 5 | 6 | for d in $(go list ./... | grep -v vendor); do 7 | go test -race -coverprofile=profile.out -covermode=atomic "$d" 8 | if [ -f profile.out ]; then 9 | cat profile.out >> coverage.txt 10 | rm profile.out 11 | fi 12 | done 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | package cpu 8 | 9 | func getisar0() uint64 10 | func getisar1() uint64 11 | func getpfr0() uint64 12 | func getzfr0() uint64 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/ptrace_ios.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { 10 | return ENOTSUP 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/detection.go: -------------------------------------------------------------------------------- 1 | package sha1cd 2 | 3 | import "hash" 4 | 5 | type CollisionResistantHash interface { 6 | // CollisionResistantSum extends on Sum by returning an additional boolean 7 | // which indicates whether a collision was found during the hashing process. 8 | CollisionResistantSum(b []byte) ([]byte, bool) 9 | 10 | hash.Hash 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | import "syscall" 10 | 11 | type Errno = syscall.Errno 12 | type SysProcAttr = syscall.SysProcAttr 13 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/revision.go: -------------------------------------------------------------------------------- 1 | package plumbing 2 | 3 | // Revision represents a git revision 4 | // to get more details about git revisions 5 | // please check git manual page : 6 | // https://www.kernel.org/pub/software/scm/git/docs/gitrevisions.html 7 | type Revision string 8 | 9 | func (r Revision) String() string { 10 | return string(r) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!amd64 && !loong64 && !ppc64le && !ppc64 && !s390x) || !gc || purego 6 | 7 | package poly1305 8 | 9 | type mac struct{ macGeneric } 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !aix && !linux && (ppc64 || ppc64le) 6 | 7 | package cpu 8 | 9 | func archInit() { 10 | PPC64.IsPOWER8 = true 11 | Initialized = true 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gccgo 6 | 7 | package cpu 8 | 9 | func getisar0() uint64 { return 0 } 10 | func getisar1() uint64 { return 0 } 11 | func getpfr0() uint64 { return 0 } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && !arm && !arm64 && !loong64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x && !riscv64 6 | 7 | package cpu 8 | 9 | func doinit() {} 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux || !go1.24 6 | 7 | package unix 8 | 9 | func vgetrandom(p []byte, flags uint32) (ret int, supported bool) { 10 | return -1, false 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && linux && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //go:noescape 12 | func gettimeofday(tv *Timeval) (err syscall.Errno) 13 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/pflag/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | 3 | language: go 4 | 5 | go: 6 | - 1.9.x 7 | - 1.10.x 8 | - 1.11.x 9 | - tip 10 | 11 | matrix: 12 | allow_failures: 13 | - go: tip 14 | 15 | install: 16 | - go get golang.org/x/lint/golint 17 | - export PATH=$GOPATH/bin:$PATH 18 | - go install ./... 19 | 20 | script: 21 | - verify/all.sh -v 22 | - go test ./... 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | //go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64 6 | 7 | package unix 8 | 9 | const isBigEndian = true 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/ptrace_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin && !ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) error { 10 | return ptrace1(request, pid, addr, data) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/keccakf_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && !purego && gc 6 | 7 | package sha3 8 | 9 | // This function is implemented in keccakf_amd64.s. 10 | 11 | //go:noescape 12 | 13 | func keccakF1600(a *[25]uint64) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_x86.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 || amd64p32 || (amd64 && (!darwin || !gc)) 6 | 7 | package cpu 8 | 9 | func darwinSupportsAVX512() bool { 10 | panic("only implemented for gc && amd64 && darwin") 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/errors.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // AnError is an error instance useful for testing. If the code does not care 8 | // about error specifics, and only needs to return the error for example, this 9 | // error should be used to make the test code more readable. 10 | var AnError = errors.New("assert.AnError general error for testing") 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | const ( 10 | R_OK = 0x4 11 | W_OK = 0x2 12 | X_OK = 0x1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/storer/shallow.go: -------------------------------------------------------------------------------- 1 | package storer 2 | 3 | import "github.com/go-git/go-git/v5/plumbing" 4 | 5 | // ShallowStorer is a storage of references to shallow commits by hash, 6 | // meaning that these commits have missing parents because of a shallow fetch. 7 | type ShallowStorer interface { 8 | SetShallow([]plumbing.Hash) error 9 | Shallow() ([]plumbing.Hash, error) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/xanzy/ssh-agent/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/blake2b/blake2b_ref.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !amd64 || purego || !gc 6 | 7 | package blake2b 8 | 9 | func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) { 10 | hashBlocksGeneric(h, c, flag, blocks) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/Makefile: -------------------------------------------------------------------------------- 1 | # General 2 | WORKDIR = $(PWD) 3 | 4 | # Go parameters 5 | GOCMD = go 6 | GOTEST = $(GOCMD) test 7 | 8 | # Coverage 9 | COVERAGE_REPORT = coverage.out 10 | COVERAGE_MODE = count 11 | 12 | test: 13 | $(GOTEST) ./... 14 | 15 | test-coverage: 16 | echo "" > $(COVERAGE_REPORT); \ 17 | $(GOTEST) -coverprofile=$(COVERAGE_REPORT) -coverpkg=./... -covermode=$(COVERAGE_MODE) ./... 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !386 && !amd64 && !amd64p32 && !arm64 6 | 7 | package cpu 8 | 9 | func archInit() { 10 | if err := readHWCAP(); err != nil { 11 | return 12 | } 13 | doinit() 14 | Initialized = true 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_mips64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build mips64 || mips64le 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 32 10 | 11 | func initOptions() { 12 | options = []option{ 13 | {Name: "msa", Feature: &MIPS64X.HasMSA}, 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/shake_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !gc || purego || !s390x 6 | 7 | package sha3 8 | 9 | func newShake128() *state { 10 | return newShake128Generic() 11 | } 12 | 13 | func newShake256() *state { 14 | return newShake256Generic() 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | //go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh 6 | 7 | package unix 8 | 9 | const isBigEndian = false 10 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/AUTHORS.txt: -------------------------------------------------------------------------------- 1 | Carlos A Becker 2 | Dustin Spicuzza 3 | Eugene Terentev 4 | Kevin Burke 5 | Mark Nevill 6 | Scott Lessans 7 | Sergey Lukjanov 8 | Wayne Ashley Berry 9 | santosh653 <70637961+santosh653@users.noreply.github.com> 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/mmap_nomremap.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | var mapper = &mmapper{ 10 | active: make(map[*byte][]byte), 11 | mmap: mmap, 12 | munmap: munmap, 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/mksyscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build generate 6 | 7 | package windows 8 | 9 | //go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go setupapi_windows.go 10 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/hash/hash_sha1.go: -------------------------------------------------------------------------------- 1 | //go:build !sha256 2 | // +build !sha256 3 | 4 | package hash 5 | 6 | import "crypto" 7 | 8 | const ( 9 | // CryptoType defines what hash algorithm is being used. 10 | CryptoType = crypto.SHA1 11 | // Size defines the amount of bytes the hash yields. 12 | Size = 20 13 | // HexSize defines the strings size of the hash when represented in hexadecimal. 14 | HexSize = 40 15 | ) 16 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/hash/hash_sha256.go: -------------------------------------------------------------------------------- 1 | //go:build sha256 2 | // +build sha256 3 | 4 | package hash 5 | 6 | import "crypto" 7 | 8 | const ( 9 | // CryptoType defines what hash algorithm is being used. 10 | CryptoType = crypto.SHA256 11 | // Size defines the amount of bytes the hash yields. 12 | Size = 32 13 | // HexSize defines the strings size of the hash when represented in hexadecimal. 14 | HexSize = 64 15 | ) 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/vgetrandom_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && go1.24 6 | 7 | package unix 8 | 9 | import _ "unsafe" 10 | 11 | //go:linkname vgetrandom runtime.vgetrandom 12 | //go:noescape 13 | func vgetrandom(p []byte, flags uint32) (ret int, supported bool) 14 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/internal/revision/token.go: -------------------------------------------------------------------------------- 1 | package revision 2 | 3 | // token represents a entity extracted from string parsing 4 | type token int 5 | 6 | const ( 7 | eof token = iota 8 | 9 | aslash 10 | asterisk 11 | at 12 | caret 13 | cbrace 14 | colon 15 | control 16 | dot 17 | emark 18 | minus 19 | number 20 | obrace 21 | obracket 22 | qmark 23 | slash 24 | space 25 | tilde 26 | tokenError 27 | word 28 | ) 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_loong64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2025 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | #include "textflag.h" 6 | 7 | // func get_cpucfg(reg uint32) uint32 8 | TEXT ·get_cpucfg(SB), NOSPLIT|NOFRAME, $0 9 | MOVW reg+0(FP), R5 10 | // CPUCFG R5, R4 = 0x00006ca4 11 | WORD $0x00006ca4 12 | MOVW R4, ret+8(FP) 13 | RET 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/execabs/execabs_go118.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.19 6 | 7 | package execabs 8 | 9 | import "os/exec" 10 | 11 | func isGo119ErrDot(err error) bool { 12 | return false 13 | } 14 | 15 | func isGo119ErrFieldSet(cmd *exec.Cmd) bool { 16 | return false 17 | } 18 | -------------------------------------------------------------------------------- /vendor/dario.cat/mergo/SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | ## Supported Versions 4 | 5 | | Version | Supported | 6 | | ------- | ------------------ | 7 | | 0.3.x | :white_check_mark: | 8 | | < 0.3 | :x: | 9 | 10 | ## Security contact information 11 | 12 | To report a security vulnerability, please use the 13 | [Tidelift security contact](https://tidelift.com/security). 14 | Tidelift will coordinate the fix and disclosure. 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_openbsd_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | #include "textflag.h" 6 | 7 | TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0 8 | JMP libc_sysctl(SB) 9 | 10 | GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8 11 | DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB) 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build ppc64 || ppc64le 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 128 10 | 11 | func initOptions() { 12 | options = []option{ 13 | {Name: "darn", Feature: &PPC64.HasDARN}, 14 | {Name: "scv", Feature: &PPC64.HasSCV}, 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x448/curve_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || purego 2 | // +build !amd64 purego 3 | 4 | package x448 5 | 6 | import fp "github.com/cloudflare/circl/math/fp448" 7 | 8 | func double(x, z *fp.Elt) { doubleGeneric(x, z) } 9 | func diffAdd(w *[5]fp.Elt, b uint) { diffAddGeneric(w, b) } 10 | func ladderStep(w *[5]fp.Elt, b uint) { ladderStepGeneric(w, b) } 11 | func mulA24(z, x *fp.Elt) { mulA24Generic(z, x) } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!arm64 && !s390x && !ppc64 && !ppc64le) || !gc || purego 6 | 7 | package chacha20 8 | 9 | const bufSize = blockSize 10 | 11 | func (s *Cipher) xorKeyStreamBlocks(dst, src []byte) { 12 | s.xorKeyStreamBlocksGeneric(dst, src) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/auxv_unsupported.go: -------------------------------------------------------------------------------- 1 | // Copyright 2025 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos) 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Auxv() ([][2]uintptr, error) { 12 | return nil, syscall.ENOTSUP 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x25519/curve_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || purego 2 | // +build !amd64 purego 3 | 4 | package x25519 5 | 6 | import fp "github.com/cloudflare/circl/math/fp25519" 7 | 8 | func double(x, z *fp.Elt) { doubleGeneric(x, z) } 9 | func diffAdd(w *[5]fp.Elt, b uint) { diffAddGeneric(w, b) } 10 | func ladderStep(w *[5]fp.Elt, b uint) { ladderStepGeneric(w, b) } 11 | func mulA24(z, x *fp.Elt) { mulA24Generic(z, x) } 12 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/math/integer.go: -------------------------------------------------------------------------------- 1 | package math 2 | 3 | import "math/bits" 4 | 5 | // NextPow2 finds the next power of two (N=2^k, k>=0) greater than n. 6 | // If n is already a power of two, then this function returns n, and log2(n). 7 | func NextPow2(n uint) (N uint, k uint) { 8 | if bits.OnesCount(n) == 1 { 9 | k = uint(bits.TrailingZeros(n)) 10 | N = n 11 | } else { 12 | k = uint(bits.Len(n)) 13 | N = uint(1) << k 14 | } 15 | return 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64 6 | 7 | package cpu 8 | 9 | // IsBigEndian records whether the GOARCH's byte order is big endian. 10 | const IsBigEndian = true 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | type Signal = syscall.Signal 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/runtime_auxv_go121.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.21 6 | 7 | package cpu 8 | 9 | import ( 10 | _ "unsafe" // for linkname 11 | ) 12 | 13 | //go:linkname runtime_getAuxv runtime.getAuxv 14 | func runtime_getAuxv() []uintptr 15 | 16 | func init() { 17 | getAuxvFn = runtime_getAuxv 18 | } 19 | -------------------------------------------------------------------------------- /internal/cli/cmd/root.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | 3 | import ( 4 | "github.com/spf13/cobra" 5 | ) 6 | 7 | var rootCmd = &cobra.Command{ 8 | Use: "fleet", 9 | Short: "A modern package manager", 10 | Long: `Fleet is a package manager built with Go, designed to install, manage, and configure different tools in a simple and efficient way.`, 11 | } 12 | 13 | func Execute() error { 14 | return rootCmd.Execute() 15 | } 16 | 17 | func init() { 18 | 19 | rootCmd.AddCommand(NewSimulateCmd()) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/argon2/blamka_ref.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !amd64 || purego || !gc 6 | 7 | package argon2 8 | 9 | func processBlock(out, in1, in2 *block) { 10 | processBlockGeneric(out, in1, in2, false) 11 | } 12 | 13 | func processBlockXOR(out, in1, in2 *block) { 14 | processBlockGeneric(out, in1, in2, true) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/readdirent_getdents.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || dragonfly || freebsd || linux || netbsd || openbsd 6 | 7 | package unix 8 | 9 | // ReadDirent reads directory entries from fd and writes them into buf. 10 | func ReadDirent(fd int, buf []byte) (n int, err error) { 11 | return Getdents(fd, buf) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/runtime_auxv.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | // getAuxvFn is non-nil on Go 1.21+ (via runtime_auxv_go121.go init) 8 | // on platforms that use auxv. 9 | var getAuxvFn func() []uintptr 10 | 11 | func getAuxv() []uintptr { 12 | if getAuxvFn == nil { 13 | return nil 14 | } 15 | return getAuxvFn() 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/pagesize_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | // For Unix, get the pagesize from the runtime. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getpagesize() int { 14 | return syscall.Getpagesize() 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sysvshm_unix_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin && !ios) || zos 6 | 7 | package unix 8 | 9 | // SysvShmCtl performs control operations on the shared memory segment 10 | // specified by id. 11 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 12 | return shmctl(id, cmd, desc) 13 | } 14 | -------------------------------------------------------------------------------- /.github/workflows/build.yml: -------------------------------------------------------------------------------- 1 | name: Build 2 | 3 | on: 4 | push: 5 | branches: [main] 6 | pull_request: 7 | branches: [main] 8 | 9 | jobs: 10 | build: 11 | runs-on: ubuntu-latest 12 | 13 | steps: 14 | - name: Checkout repository 15 | uses: actions/checkout@v4 16 | 17 | - name: Set up Go 18 | uses: actions/setup-go@v5 19 | with: 20 | go-version: 1.22 21 | 22 | - name: Build binary 23 | run: | 24 | go build -v ./... 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh || wasm 6 | 7 | package cpu 8 | 9 | // IsBigEndian records whether the GOARCH's byte order is big endian. 10 | const IsBigEndian = false 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/execabs/execabs_go119.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.19 6 | 7 | package execabs 8 | 9 | import ( 10 | "errors" 11 | "os/exec" 12 | ) 13 | 14 | func isGo119ErrDot(err error) bool { 15 | return errors.Is(err, exec.ErrDot) 16 | } 17 | 18 | func isGo119ErrFieldSet(cmd *exec.Cmd) bool { 19 | return cmd.Err != nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 11 | // 12 | 13 | TEXT ·syscall6(SB),NOSPLIT,$0-88 14 | JMP syscall·syscall6(SB) 15 | 16 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSyscall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_aix_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 11 | // 12 | 13 | TEXT ·syscall6(SB),NOSPLIT,$0-88 14 | JMP syscall·syscall6(SB) 15 | 16 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSyscall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm && gc && linux 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | -------------------------------------------------------------------------------- /.github/workflows/test.yml: -------------------------------------------------------------------------------- 1 | name: Test 2 | 3 | on: 4 | push: 5 | branches: [main] 6 | pull_request: 7 | branches: [main] 8 | 9 | jobs: 10 | test: 11 | runs-on: ubuntu-latest 12 | 13 | steps: 14 | - name: Checkout repository 15 | uses: actions/checkout@v4 16 | 17 | - name: Set up Go 18 | uses: actions/setup-go@v5 19 | with: 20 | go-version: 1.22 21 | 22 | - name: Run unit and integration tests 23 | run: | 24 | go test -v ./... 25 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/pkg/guid/guid_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | // +build windows 3 | 4 | package guid 5 | 6 | import "golang.org/x/sys/windows" 7 | 8 | // GUID represents a GUID/UUID. It has the same structure as 9 | // golang.org/x/sys/windows.GUID so that it can be used with functions expecting 10 | // that type. It is defined as its own type so that stringification and 11 | // marshaling can be supported. The representation matches that used by native 12 | // Windows code. 13 | type GUID windows.GUID 14 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/storer/storer.go: -------------------------------------------------------------------------------- 1 | package storer 2 | 3 | // Storer is a basic storer for encoded objects and references. 4 | type Storer interface { 5 | EncodedObjectStorer 6 | ReferenceStorer 7 | } 8 | 9 | // Initializer should be implemented by storers that require to perform any 10 | // operation when creating a new repository (i.e. git init). 11 | type Initializer interface { 12 | // Init performs initialization of the storer and returns the error, if 13 | // any. 14 | Init() error 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_solaris_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 11 | // 12 | 13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 14 | JMP syscall·sysvicall6(SB) 15 | 16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSysvicall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle) || (linux && ppc) 6 | 7 | package unix 8 | 9 | func init() { 10 | // On 32-bit Linux systems, the fcntl syscall that matches Go's 11 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. 12 | fcntl64Syscall = SYS_FCNTL64 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_alarm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (386 || amd64 || mips || mipsle || mips64 || mipsle || ppc64 || ppc64le || ppc || s390x || sparc64) 6 | 7 | package unix 8 | 9 | // SYS_ALARM is not defined on arm or riscv, but is available for other GOARCH 10 | // values. 11 | 12 | //sys Alarm(seconds uint) (remaining uint, err error) 13 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/Makefile: -------------------------------------------------------------------------------- 1 | # Go parameters 2 | GOCMD = go 3 | GOTEST = $(GOCMD) test 4 | WASIRUN_WRAPPER := $(CURDIR)/scripts/wasirun-wrapper 5 | 6 | .PHONY: test 7 | test: 8 | $(GOTEST) -race ./... 9 | 10 | test-coverage: 11 | echo "" > $(COVERAGE_REPORT); \ 12 | $(GOTEST) -coverprofile=$(COVERAGE_REPORT) -coverpkg=./... -covermode=$(COVERAGE_MODE) ./... 13 | 14 | .PHONY: wasitest 15 | wasitest: export GOARCH=wasm 16 | wasitest: export GOOS=wasip1 17 | wasitest: 18 | $(GOTEST) -exec $(WASIRUN_WRAPPER) ./... 19 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/internal/sha3/xor.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!amd64 && !386 && !ppc64le) || appengine 6 | // +build !amd64,!386,!ppc64le appengine 7 | 8 | package sha3 9 | 10 | // A storageBuf is an aligned array of maxRate bytes. 11 | type storageBuf [maxRate]byte 12 | 13 | func (b *storageBuf) asBytes() *[maxRate]byte { 14 | return (*[maxRate]byte)(b) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/math/fp448/fp_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || purego 2 | // +build !amd64 purego 3 | 4 | package fp448 5 | 6 | func cmov(x, y *Elt, n uint) { cmovGeneric(x, y, n) } 7 | func cswap(x, y *Elt, n uint) { cswapGeneric(x, y, n) } 8 | func add(z, x, y *Elt) { addGeneric(z, x, y) } 9 | func sub(z, x, y *Elt) { subGeneric(z, x, y) } 10 | func addsub(x, y *Elt) { addsubGeneric(x, y) } 11 | func mul(z, x, y *Elt) { mulGeneric(z, x, y) } 12 | func sqr(z, x *Elt) { sqrGeneric(z, x) } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_wasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build wasm 6 | 7 | package cpu 8 | 9 | // We're compiling the cpu package for an unknown (software-abstracted) CPU. 10 | // Make CacheLinePad an empty struct and hope that the usual struct alignment 11 | // rules are good enough. 12 | 13 | const cacheLineSize = 0 14 | 15 | func initOptions() {} 16 | 17 | func archInit() {} 18 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/doc.go: -------------------------------------------------------------------------------- 1 | // A highly extensible git implementation in pure Go. 2 | // 3 | // go-git aims to reach the completeness of libgit2 or jgit, nowadays covers the 4 | // majority of the plumbing read operations and some of the main write 5 | // operations, but lacks the main porcelain operations such as merges. 6 | // 7 | // It is highly extensible, we have been following the open/close principle in 8 | // its design to facilitate extensions, mainly focusing the efforts on the 9 | // persistence of the objects. 10 | package git 11 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/forward_assertions.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | // Assertions provides assertion methods around the 4 | // TestingT interface. 5 | type Assertions struct { 6 | t TestingT 7 | } 8 | 9 | // New makes a new Assertions object for the specified TestingT. 10 | func New(t TestingT) *Assertions { 11 | return &Assertions{ 12 | t: t, 13 | } 14 | } 15 | 16 | //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs" 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego 6 | 7 | package chacha20 8 | 9 | const bufSize = 256 10 | 11 | //go:noescape 12 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32) 13 | 14 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 15 | xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/hashes_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !gc || purego || !s390x 6 | 7 | package sha3 8 | 9 | func new224() *state { 10 | return new224Generic() 11 | } 12 | 13 | func new256() *state { 14 | return new256Generic() 15 | } 16 | 17 | func new384() *state { 18 | return new384Generic() 19 | } 20 | 21 | func new512() *state { 22 | return new512Generic() 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/packet/recipient.go: -------------------------------------------------------------------------------- 1 | package packet 2 | 3 | // Recipient type represents a Intended Recipient Fingerprint subpacket 4 | // See https://datatracker.ietf.org/doc/html/draft-ietf-openpgp-crypto-refresh#name-intended-recipient-fingerpr 5 | type Recipient struct { 6 | KeyVersion int 7 | Fingerprint []byte 8 | } 9 | 10 | func (r *Recipient) Serialize() []byte { 11 | packet := make([]byte, len(r.Fingerprint)+1) 12 | packet[0] = byte(r.KeyVersion) 13 | copy(packet[1:], r.Fingerprint) 14 | return packet 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/sergi/go-diff/diffmatchpatch/operation_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Operation -trimprefix=Diff"; DO NOT EDIT. 2 | 3 | package diffmatchpatch 4 | 5 | import "fmt" 6 | 7 | const _Operation_name = "DeleteEqualInsert" 8 | 9 | var _Operation_index = [...]uint8{0, 6, 11, 17} 10 | 11 | func (i Operation) String() string { 12 | i -= -1 13 | if i < 0 || i >= Operation(len(_Operation_index)-1) { 14 | return fmt.Sprintf("Operation(%d)", i+-1) 15 | } 16 | return _Operation_name[_Operation_index[i]:_Operation_index[i+1]] 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/storage/filesystem/module.go: -------------------------------------------------------------------------------- 1 | package filesystem 2 | 3 | import ( 4 | "github.com/go-git/go-git/v5/plumbing/cache" 5 | "github.com/go-git/go-git/v5/storage" 6 | "github.com/go-git/go-git/v5/storage/filesystem/dotgit" 7 | ) 8 | 9 | type ModuleStorage struct { 10 | dir *dotgit.DotGit 11 | } 12 | 13 | func (s *ModuleStorage) Module(name string) (storage.Storer, error) { 14 | fs, err := s.dir.Module(name) 15 | if err != nil { 16 | return nil, err 17 | } 18 | 19 | return NewStorage(fs, cache.NewObjectLRUDefault()), nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/ubc/ubc_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || noasm || !gc 2 | // +build !amd64 noasm !gc 3 | 4 | package ubc 5 | 6 | // Check takes as input an expanded message block and verifies the unavoidable bitconditions 7 | // for all listed DVs. It returns a dvmask where each bit belonging to a DV is set if all 8 | // unavoidable bitconditions for that DV have been met. 9 | // Thus, one needs to do the recompression check for each DV that has its bit set. 10 | func CalculateDvMask(W [80]uint32) uint32 { 11 | return CalculateDvMaskGeneric(W) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gccgo && linux && amd64 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //extern gettimeofday 12 | func realGettimeofday(*Timeval, *byte) int32 13 | 14 | func gettimeofday(tv *Timeval) (err syscall.Errno) { 15 | r := realGettimeofday(tv, nil) 16 | if r < 0 { 17 | return syscall.GetErrno() 18 | } 19 | return 0 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/internal/fs/security.go: -------------------------------------------------------------------------------- 1 | package fs 2 | 3 | // https://learn.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level 4 | type SecurityImpersonationLevel int32 // C default enums underlying type is `int`, which is Go `int32` 5 | 6 | // Impersonation levels 7 | const ( 8 | SecurityAnonymous SecurityImpersonationLevel = 0 9 | SecurityIdentification SecurityImpersonationLevel = 1 10 | SecurityImpersonation SecurityImpersonationLevel = 2 11 | SecurityDelegation SecurityImpersonationLevel = 3 12 | ) 13 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/pkg/guid/guid_nonwindows.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | // +build !windows 3 | 4 | package guid 5 | 6 | // GUID represents a GUID/UUID. It has the same structure as 7 | // golang.org/x/sys/windows.GUID so that it can be used with functions expecting 8 | // that type. It is defined as its own type as that is only available to builds 9 | // targeted at `windows`. The representation matches that used by native Windows 10 | // code. 11 | type GUID struct { 12 | Data1 uint32 13 | Data2 uint16 14 | Data3 uint16 15 | Data4 [8]byte 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/common.go: -------------------------------------------------------------------------------- 1 | package git 2 | 3 | import "strings" 4 | 5 | // countLines returns the number of lines in a string à la git, this is 6 | // The newline character is assumed to be '\n'. The empty string 7 | // contains 0 lines. If the last line of the string doesn't end with a 8 | // newline, it will still be considered a line. 9 | func countLines(s string) int { 10 | if s == "" { 11 | return 0 12 | } 13 | 14 | nEOL := strings.Count(s, "\n") 15 | if strings.HasSuffix(s, "\n") { 16 | return nEOL 17 | } 18 | 19 | return nEOL + 1 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego && (ppc64 || ppc64le) 6 | 7 | package chacha20 8 | 9 | const bufSize = 256 10 | 11 | //go:noescape 12 | func chaCha20_ctr32_vsx(out, inp *byte, len int, key *[8]uint32, counter *uint32) 13 | 14 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 15 | chaCha20_ctr32_vsx(&dst[0], &src[0], len(src), &c.key, &c.counter) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gc 6 | 7 | package unix 8 | 9 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail. 10 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 11 | 12 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't 13 | // fail. 14 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 15 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/math/fp25519/fp_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || purego 2 | // +build !amd64 purego 3 | 4 | package fp25519 5 | 6 | func cmov(x, y *Elt, n uint) { cmovGeneric(x, y, n) } 7 | func cswap(x, y *Elt, n uint) { cswapGeneric(x, y, n) } 8 | func add(z, x, y *Elt) { addGeneric(z, x, y) } 9 | func sub(z, x, y *Elt) { subGeneric(z, x, y) } 10 | func addsub(x, y *Elt) { addsubGeneric(x, y) } 11 | func mul(z, x, y *Elt) { mulGeneric(z, x, y) } 12 | func sqr(z, x *Elt) { sqrGeneric(z, x) } 13 | func modp(z *Elt) { modpGeneric(z) } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_x86.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (386 || amd64 || amd64p32) && gc 6 | 7 | package cpu 8 | 9 | // cpuid is implemented in cpu_gc_x86.s for gc compiler 10 | // and in cpu_gccgo.c for gccgo. 11 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) 12 | 13 | // xgetbv with ecx = 0 is implemented in cpu_gc_x86.s for gc compiler 14 | // and in cpu_gccgo.c for gccgo. 15 | func xgetbv() (eax, edx uint32) 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows && !race 6 | 7 | package windows 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_js.go: -------------------------------------------------------------------------------- 1 | // +build js 2 | 3 | package git 4 | 5 | import ( 6 | "syscall" 7 | "time" 8 | 9 | "github.com/go-git/go-git/v5/plumbing/format/index" 10 | ) 11 | 12 | func init() { 13 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 14 | if os, ok := sys.(*syscall.Stat_t); ok { 15 | e.CreatedAt = time.Unix(int64(os.Ctime), int64(os.CtimeNsec)) 16 | e.Dev = uint32(os.Dev) 17 | e.Inode = uint32(os.Ino) 18 | e.GID = os.Gid 19 | e.UID = os.Uid 20 | } 21 | } 22 | } 23 | 24 | func isSymlinkWindowsNonAdmin(err error) bool { 25 | return false 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_hurd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 && hurd 6 | 7 | package unix 8 | 9 | const ( 10 | TIOCGETA = 0x62251713 11 | ) 12 | 13 | type Winsize struct { 14 | Row uint16 15 | Col uint16 16 | Xpixel uint16 17 | Ypixel uint16 18 | } 19 | 20 | type Termios struct { 21 | Iflag uint32 22 | Oflag uint32 23 | Cflag uint32 24 | Lflag uint32 25 | Cc [20]uint8 26 | Ispeed int32 27 | Ospeed int32 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_bsd.go: -------------------------------------------------------------------------------- 1 | // +build darwin freebsd netbsd 2 | 3 | package git 4 | 5 | import ( 6 | "syscall" 7 | "time" 8 | 9 | "github.com/go-git/go-git/v5/plumbing/format/index" 10 | ) 11 | 12 | func init() { 13 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 14 | if os, ok := sys.(*syscall.Stat_t); ok { 15 | e.CreatedAt = time.Unix(os.Atimespec.Unix()) 16 | e.Dev = uint32(os.Dev) 17 | e.Inode = uint32(os.Ino) 18 | e.GID = os.Gid 19 | e.UID = os.Uid 20 | } 21 | } 22 | } 23 | 24 | func isSymlinkWindowsNonAdmin(err error) bool { 25 | return false 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_linux.go: -------------------------------------------------------------------------------- 1 | //go:build linux 2 | // +build linux 3 | 4 | package git 5 | 6 | import ( 7 | "syscall" 8 | "time" 9 | 10 | "github.com/go-git/go-git/v5/plumbing/format/index" 11 | ) 12 | 13 | func init() { 14 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 15 | if os, ok := sys.(*syscall.Stat_t); ok { 16 | e.CreatedAt = time.Unix(os.Ctim.Unix()) 17 | e.Dev = uint32(os.Dev) 18 | e.Inode = uint32(os.Ino) 19 | e.GID = os.Gid 20 | e.UID = os.Uid 21 | } 22 | } 23 | } 24 | 25 | func isSymlinkWindowsNonAdmin(_ error) bool { 26 | return false 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/inconshreveable/mousetrap/trap_others.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | // +build !windows 3 | 4 | package mousetrap 5 | 6 | // StartedByExplorer returns true if the program was invoked by the user 7 | // double-clicking on the executable from explorer.exe 8 | // 9 | // It is conservative and returns false if any of the internal calls fail. 10 | // It does not guarantee that the program was run from a terminal. It only can tell you 11 | // whether it was launched from explorer.exe 12 | // 13 | // On non-Windows platforms, it always returns false. 14 | func StartedByExplorer() bool { 15 | return false 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/ubc/ubc_amd64.go: -------------------------------------------------------------------------------- 1 | //go:build !noasm && gc && amd64 2 | // +build !noasm,gc,amd64 3 | 4 | package ubc 5 | 6 | func CalculateDvMaskAMD64(W [80]uint32) uint32 7 | 8 | // Check takes as input an expanded message block and verifies the unavoidable bitconditions 9 | // for all listed DVs. It returns a dvmask where each bit belonging to a DV is set if all 10 | // unavoidable bitconditions for that DV have been met. 11 | // Thus, one needs to do the recompression check for each DV that has its bit set. 12 | func CalculateDvMask(W [80]uint32) uint32 { 13 | return CalculateDvMaskAMD64(W) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (mips64 || mips64le) 6 | 7 | package cpu 8 | 9 | // HWCAP bits. These are exposed by the Linux kernel 5.4. 10 | const ( 11 | // CPU features 12 | hwcap_MIPS_MSA = 1 << 1 13 | ) 14 | 15 | func doinit() { 16 | // HWCAP feature bits 17 | MIPS64X.HasMSA = isSet(hwCap, hwcap_MIPS_MSA) 18 | } 19 | 20 | func isSet(hwc uint, value uint) bool { 21 | return hwc&value != 0 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/fatih/color/color_windows.go: -------------------------------------------------------------------------------- 1 | package color 2 | 3 | import ( 4 | "os" 5 | 6 | "golang.org/x/sys/windows" 7 | ) 8 | 9 | func init() { 10 | // Opt-in for ansi color support for current process. 11 | // https://learn.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#output-sequences 12 | var outMode uint32 13 | out := windows.Handle(os.Stdout.Fd()) 14 | if err := windows.GetConsoleMode(out, &outMode); err != nil { 15 | return 16 | } 17 | outMode |= windows.ENABLE_PROCESSED_OUTPUT | windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING 18 | _ = windows.SetConsoleMode(out, outMode) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_unix_other.go: -------------------------------------------------------------------------------- 1 | // +build openbsd dragonfly solaris 2 | 3 | package git 4 | 5 | import ( 6 | "syscall" 7 | "time" 8 | 9 | "github.com/go-git/go-git/v5/plumbing/format/index" 10 | ) 11 | 12 | func init() { 13 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 14 | if os, ok := sys.(*syscall.Stat_t); ok { 15 | e.CreatedAt = time.Unix(os.Atim.Unix()) 16 | e.Dev = uint32(os.Dev) 17 | e.Inode = uint32(os.Ino) 18 | e.GID = os.Gid 19 | e.UID = os.Uid 20 | } 21 | } 22 | } 23 | 24 | func isSymlinkWindowsNonAdmin(err error) bool { 25 | return false 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/str.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + itoa(-val) 12 | } 13 | var buf [32]byte // big enough for int64 14 | i := len(buf) - 1 15 | for val >= 10 { 16 | buf[i] = byte(val%10 + '0') 17 | i-- 18 | val /= 10 19 | } 20 | buf[i] = byte(val + '0') 21 | return string(buf[i:]) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/gopkg.in/yaml.v3/NOTICE: -------------------------------------------------------------------------------- 1 | Copyright 2011-2016 Canonical Ltd. 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_others.go: -------------------------------------------------------------------------------- 1 | //go:build (appengine || js || nacl || tinygo || wasm) && !windows 2 | // +build appengine js nacl tinygo wasm 3 | // +build !windows 4 | 5 | package isatty 6 | 7 | // IsTerminal returns true if the file descriptor is terminal which 8 | // is always false on js and appengine classic which is a sandboxed PaaS. 9 | func IsTerminal(fd uintptr) bool { 10 | return false 11 | } 12 | 13 | // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2 14 | // terminal. This is also always false on this environment. 15 | func IsCygwinTerminal(fd uintptr) bool { 16 | return false 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sysvshm_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux 6 | 7 | package unix 8 | 9 | import "runtime" 10 | 11 | // SysvShmCtl performs control operations on the shared memory segment 12 | // specified by id. 13 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 14 | if runtime.GOARCH == "arm" || 15 | runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le" { 16 | cmd |= ipc_64 17 | } 18 | 19 | return shmctl(id, cmd, desc) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/sergi/go-diff/diffmatchpatch/mathutil.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012-2016 The go-diff authors. All rights reserved. 2 | // https://github.com/sergi/go-diff 3 | // See the included LICENSE file for license details. 4 | // 5 | // go-diff is a Go implementation of Google's Diff, Match, and Patch library 6 | // Original library is Copyright (c) 2006 Google Inc. 7 | // http://code.google.com/p/google-diff-match-patch/ 8 | 9 | package diffmatchpatch 10 | 11 | func min(x, y int) int { 12 | if x < y { 13 | return x 14 | } 15 | return y 16 | } 17 | 18 | func max(x, y int) int { 19 | if x > y { 20 | return x 21 | } 22 | return y 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_plan9.go: -------------------------------------------------------------------------------- 1 | //go:build plan9 2 | // +build plan9 3 | 4 | package isatty 5 | 6 | import ( 7 | "syscall" 8 | ) 9 | 10 | // IsTerminal returns true if the given file descriptor is a terminal. 11 | func IsTerminal(fd uintptr) bool { 12 | path, err := syscall.Fd2path(int(fd)) 13 | if err != nil { 14 | return false 15 | } 16 | return path == "/dev/cons" || path == "/mnt/term/dev/cons" 17 | } 18 | 19 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 20 | // terminal. This is also always false on this environment. 21 | func IsCygwinTerminal(fd uintptr) bool { 22 | return false 23 | } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sockcmsg_dragonfly.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | // Round the length of a raw sockaddr up to align it properly. 8 | func cmsgAlignOf(salen int) int { 9 | salign := SizeofPtr 10 | if SizeofPtr == 8 && !supportsABI(_dragonflyABIChangeVersion) { 11 | // 64-bit Dragonfly before the September 2019 ABI changes still requires 12 | // 32-bit aligned access to network subsystem. 13 | salign = 4 14 | } 15 | return (salen + salign - 1) & ^(salign - 1) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_riscv64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build riscv64 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 64 10 | 11 | func initOptions() { 12 | options = []option{ 13 | {Name: "fastmisaligned", Feature: &RISCV64.HasFastMisaligned}, 14 | {Name: "c", Feature: &RISCV64.HasC}, 15 | {Name: "v", Feature: &RISCV64.HasV}, 16 | {Name: "zba", Feature: &RISCV64.HasZba}, 17 | {Name: "zbb", Feature: &RISCV64.HasZbb}, 18 | {Name: "zbs", Feature: &RISCV64.HasZbs}, 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_tcgets.go: -------------------------------------------------------------------------------- 1 | //go:build (linux || aix || zos) && !appengine && !tinygo 2 | // +build linux aix zos 3 | // +build !appengine 4 | // +build !tinygo 5 | 6 | package isatty 7 | 8 | import "golang.org/x/sys/unix" 9 | 10 | // IsTerminal return true if the file descriptor is terminal. 11 | func IsTerminal(fd uintptr) bool { 12 | _, err := unix.IoctlGetTermios(int(fd), unix.TCGETS) 13 | return err == nil 14 | } 15 | 16 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 17 | // terminal. This is also always false on this environment. 18 | func IsCygwinTerminal(fd uintptr) bool { 19 | return false 20 | } 21 | -------------------------------------------------------------------------------- /vendor/dario.cat/mergo/.gitignore: -------------------------------------------------------------------------------- 1 | #### joe made this: http://goel.io/joe 2 | 3 | #### go #### 4 | # Binaries for programs and plugins 5 | *.exe 6 | *.dll 7 | *.so 8 | *.dylib 9 | 10 | # Test binary, build with `go test -c` 11 | *.test 12 | 13 | # Output of the go coverage tool, specifically when used with LiteIDE 14 | *.out 15 | 16 | # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736 17 | .glide/ 18 | 19 | #### vim #### 20 | # Swap 21 | [._]*.s[a-v][a-z] 22 | [._]*.sw[a-p] 23 | [._]s[a-v][a-z] 24 | [._]sw[a-p] 25 | 26 | # Session 27 | Session.vim 28 | 29 | # Temporary 30 | .netrwhist 31 | *~ 32 | # Auto-generated tag files 33 | tags 34 | -------------------------------------------------------------------------------- /vendor/github.com/cyphar/filepath-securejoin/gocompat_errors_go120.go: -------------------------------------------------------------------------------- 1 | //go:build linux && go1.20 2 | 3 | // Copyright (C) 2024 SUSE LLC. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | package securejoin 8 | 9 | import ( 10 | "fmt" 11 | ) 12 | 13 | // wrapBaseError is a helper that is equivalent to fmt.Errorf("%w: %w"), except 14 | // that on pre-1.20 Go versions only errors.Is() works properly (errors.Unwrap) 15 | // is only guaranteed to give you baseErr. 16 | func wrapBaseError(baseErr, extraErr error) error { 17 | return fmt.Errorf("%w: %w", extraErr, baseErr) 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/skeema/knownhosts/NOTICE: -------------------------------------------------------------------------------- 1 | Copyright 2025 Skeema LLC and the Skeema Knownhosts authors 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changes 2 | 3 | ## Version 1.2 4 | 5 | Previously, if a Host declaration or a value had trailing whitespace, that 6 | whitespace would have been included as part of the value. This led to unexpected 7 | consequences. For example: 8 | 9 | ``` 10 | Host example # A comment 11 | HostName example.com # Another comment 12 | ``` 13 | 14 | Prior to version 1.2, the value for Host would have been "example " and the 15 | value for HostName would have been "example.com ". Both of these are 16 | unintuitive. 17 | 18 | Instead, we strip the trailing whitespace in the configuration, which leads to 19 | more intuitive behavior. 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || (darwin && !race) || (linux && !race) || (freebsd && !race) || netbsd || openbsd || solaris || dragonfly || zos 6 | 7 | package unix 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gc && 386 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | 15 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 16 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 17 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/osfs/os_js.go: -------------------------------------------------------------------------------- 1 | //go:build js 2 | // +build js 3 | 4 | package osfs 5 | 6 | import ( 7 | "github.com/go-git/go-billy/v5" 8 | "github.com/go-git/go-billy/v5/helper/chroot" 9 | "github.com/go-git/go-billy/v5/memfs" 10 | ) 11 | 12 | // globalMemFs is the global memory fs 13 | var globalMemFs = memfs.New() 14 | 15 | // Default Filesystem representing the root of in-memory filesystem for a 16 | // js/wasm environment. 17 | var Default = memfs.New() 18 | 19 | // New returns a new OS filesystem. 20 | func New(baseDir string, _ ...Option) billy.Filesystem { 21 | return chroot.New(Default, Default.Join("/", baseDir)) 22 | } 23 | 24 | type options struct { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/Dockerfile.arm: -------------------------------------------------------------------------------- 1 | FROM golang:1.23@sha256:51a6466e8dbf3e00e422eb0f7a97ac450b2d57b33617bbe8d2ee0bddcd9d0d37 2 | 3 | ENV GOOS=linux 4 | ENV GOARCH=arm 5 | ENV CGO_ENABLED=1 6 | ENV CC=arm-linux-gnueabihf-gcc 7 | ENV PATH="/go/bin/${GOOS}_${GOARCH}:${PATH}" 8 | ENV PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig 9 | 10 | RUN dpkg --add-architecture armhf \ 11 | && apt update \ 12 | && apt install -y --no-install-recommends \ 13 | gcc-arm-linux-gnueabihf \ 14 | libc6-dev-armhf-cross \ 15 | pkg-config \ 16 | && rm -rf /var/lib/apt/lists/* 17 | 18 | COPY . /src/workdir 19 | 20 | WORKDIR /src/workdir 21 | 22 | RUN go build ./... 23 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | # Vim files https://github.com/github/gitignore/blob/master/Global/Vim.gitignore 23 | # swap 24 | [._]*.s[a-w][a-z] 25 | [._]s[a-w][a-z] 26 | # session 27 | Session.vim 28 | # temporary 29 | .netrwhist 30 | *~ 31 | # auto-generated tag files 32 | tags 33 | 34 | *.exe 35 | cobra.test 36 | bin 37 | 38 | .idea/ 39 | *.iml 40 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/types/bool.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // BoolValues defines the name and value mappings for ParseBool. 4 | var BoolValues = map[string]interface{}{ 5 | "true": true, "yes": true, "on": true, "1": true, 6 | "false": false, "no": false, "off": false, "0": false, 7 | } 8 | 9 | var boolParser = func() *EnumParser { 10 | ep := &EnumParser{} 11 | ep.AddVals(BoolValues) 12 | return ep 13 | }() 14 | 15 | // ParseBool parses bool values according to the definitions in BoolValues. 16 | // Parsing is case-insensitive. 17 | func ParseBool(s string) (bool, error) { 18 | v, err := boolParser.Parse(s) 19 | if err != nil { 20 | return false, err 21 | } 22 | return v.(bool), nil 23 | } 24 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Is your feature request related to a problem? Please describe.** 11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 12 | 13 | **Describe the solution you'd like** 14 | A clear and concise description of what you want to happen. 15 | 16 | **Describe alternatives you've considered** 17 | A clear and concise description of any alternative solutions or features you've considered. 18 | 19 | **Additional context** 20 | Add any other context or screenshots about the feature request here. 21 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/packet/packet_unsupported.go: -------------------------------------------------------------------------------- 1 | package packet 2 | 3 | import ( 4 | "io" 5 | 6 | "github.com/ProtonMail/go-crypto/openpgp/errors" 7 | ) 8 | 9 | // UnsupportedPackage represents a OpenPGP packet with a known packet type 10 | // but with unsupported content. 11 | type UnsupportedPacket struct { 12 | IncompletePacket Packet 13 | Error errors.UnsupportedError 14 | } 15 | 16 | // Implements the Packet interface 17 | func (up *UnsupportedPacket) parse(read io.Reader) error { 18 | err := up.IncompletePacket.parse(read) 19 | if castedErr, ok := err.(errors.UnsupportedError); ok { 20 | up.Error = castedErr 21 | return nil 22 | } 23 | return err 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_solaris.go: -------------------------------------------------------------------------------- 1 | //go:build solaris && !appengine 2 | // +build solaris,!appengine 3 | 4 | package isatty 5 | 6 | import ( 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | // IsTerminal returns true if the given file descriptor is a terminal. 11 | // see: https://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libc/port/gen/isatty.c 12 | func IsTerminal(fd uintptr) bool { 13 | _, err := unix.IoctlGetTermio(int(fd), unix.TCGETA) 14 | return err == nil 15 | } 16 | 17 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 18 | // terminal. This is also always false on this environment. 19 | func IsCygwinTerminal(fd uintptr) bool { 20 | return false 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/osfs/os_wasip1.go: -------------------------------------------------------------------------------- 1 | //go:build wasip1 2 | // +build wasip1 3 | 4 | package osfs 5 | 6 | import ( 7 | "os" 8 | "syscall" 9 | ) 10 | 11 | func (f *file) Lock() error { 12 | f.m.Lock() 13 | defer f.m.Unlock() 14 | return nil 15 | } 16 | 17 | func (f *file) Unlock() error { 18 | f.m.Lock() 19 | defer f.m.Unlock() 20 | return nil 21 | } 22 | 23 | func rename(from, to string) error { 24 | return os.Rename(from, to) 25 | } 26 | 27 | // umask sets umask to a new value, and returns a func which allows the 28 | // caller to reset it back to what it was originally. 29 | func umask(new int) func() { 30 | old := syscall.Umask(new) 31 | return func() { 32 | syscall.Umask(old) 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gccgo && arm 6 | 7 | package unix 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 15 | var newoffset int64 16 | offsetLow := uint32(offset & 0xffffffff) 17 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 19 | return newoffset, err 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_bsd.go: -------------------------------------------------------------------------------- 1 | //go:build (darwin || freebsd || openbsd || netbsd || dragonfly || hurd) && !appengine && !tinygo 2 | // +build darwin freebsd openbsd netbsd dragonfly hurd 3 | // +build !appengine 4 | // +build !tinygo 5 | 6 | package isatty 7 | 8 | import "golang.org/x/sys/unix" 9 | 10 | // IsTerminal return true if the file descriptor is terminal. 11 | func IsTerminal(fd uintptr) bool { 12 | _, err := unix.IoctlGetTermios(int(fd), unix.TIOCGETA) 13 | return err == nil 14 | } 15 | 16 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 17 | // terminal. This is also always false on this environment. 18 | func IsCygwinTerminal(fd uintptr) bool { 19 | return false 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || dragonfly || freebsd || (linux && !ppc64 && !ppc64le) || netbsd || openbsd || solaris) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 12 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 13 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/Dockerfile.arm64: -------------------------------------------------------------------------------- 1 | FROM golang:1.23@sha256:51a6466e8dbf3e00e422eb0f7a97ac450b2d57b33617bbe8d2ee0bddcd9d0d37 2 | 3 | ENV GOOS=linux 4 | ENV GOARCH=arm64 5 | ENV CGO_ENABLED=1 6 | ENV CC=aarch64-linux-gnu-gcc 7 | ENV PATH="/go/bin/${GOOS}_${GOARCH}:${PATH}" 8 | ENV PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig 9 | 10 | # install build & runtime dependencies 11 | RUN dpkg --add-architecture arm64 \ 12 | && apt update \ 13 | && apt install -y --no-install-recommends \ 14 | gcc-aarch64-linux-gnu \ 15 | libc6-dev-arm64-cross \ 16 | pkg-config \ 17 | && rm -rf /var/lib/apt/lists/* 18 | 19 | COPY . /src/workdir 20 | 21 | WORKDIR /src/workdir 22 | 23 | RUN go build ./... 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin && amd64 && gc 6 | 7 | #include "textflag.h" 8 | 9 | TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0 10 | JMP libc_sysctl(SB) 11 | GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8 12 | DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB) 13 | 14 | TEXT libc_sysctlbyname_trampoline<>(SB),NOSPLIT,$0-0 15 | JMP libc_sysctlbyname(SB) 16 | GLOBL ·libc_sysctlbyname_trampoline_addr(SB), RODATA, $8 17 | DATA ·libc_sysctlbyname_trampoline_addr(SB)/8, $libc_sysctlbyname_trampoline<>(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_x86.s: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (386 || amd64 || amd64p32) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) 10 | TEXT ·cpuid(SB), NOSPLIT, $0-24 11 | MOVL eaxArg+0(FP), AX 12 | MOVL ecxArg+4(FP), CX 13 | CPUID 14 | MOVL AX, eax+8(FP) 15 | MOVL BX, ebx+12(FP) 16 | MOVL CX, ecx+16(FP) 17 | MOVL DX, edx+20(FP) 18 | RET 19 | 20 | // func xgetbv() (eax, edx uint32) 21 | TEXT ·xgetbv(SB), NOSPLIT, $0-8 22 | MOVL $0, CX 23 | XGETBV 24 | MOVL AX, eax+0(FP) 25 | MOVL DX, edx+4(FP) 26 | RET 27 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/types/scan.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "reflect" 7 | ) 8 | 9 | // ScanFully uses fmt.Sscanf with verb to fully scan val into ptr. 10 | func ScanFully(ptr interface{}, val string, verb byte) error { 11 | t := reflect.ValueOf(ptr).Elem().Type() 12 | // attempt to read extra bytes to make sure the value is consumed 13 | var b []byte 14 | n, err := fmt.Sscanf(val, "%"+string(verb)+"%s", ptr, &b) 15 | switch { 16 | case n < 1 || n == 1 && err != io.EOF: 17 | return fmt.Errorf("failed to parse %q as %v: %v", val, t, err) 18 | case n > 1: 19 | return fmt.Errorf("failed to parse %q as %v: extra characters %q", val, t, string(b)) 20 | } 21 | // n == 1 && err == io.EOF 22 | return nil 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_plan9.go: -------------------------------------------------------------------------------- 1 | package git 2 | 3 | import ( 4 | "syscall" 5 | "time" 6 | 7 | "github.com/go-git/go-git/v5/plumbing/format/index" 8 | ) 9 | 10 | func init() { 11 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 12 | if os, ok := sys.(*syscall.Dir); ok { 13 | // Plan 9 doesn't have a CreatedAt field. 14 | e.CreatedAt = time.Unix(int64(os.Mtime), 0) 15 | 16 | e.Dev = uint32(os.Dev) 17 | 18 | // Plan 9 has no Inode. 19 | // ext2srv(4) appears to store Inode in Qid.Path. 20 | e.Inode = uint32(os.Qid.Path) 21 | 22 | // Plan 9 has string UID/GID 23 | e.GID = 0 24 | e.UID = 0 25 | } 26 | } 27 | } 28 | 29 | func isSymlinkWindowsNonAdmin(err error) bool { 30 | return true 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && solaris 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func (iov *Iovec) SetLen(length int) { 18 | iov.Len = uint64(length) 19 | } 20 | 21 | func (msghdr *Msghdr) SetIovlen(length int) { 22 | msghdr.Iovlen = int32(length) 23 | } 24 | 25 | func (cmsg *Cmsghdr) SetLen(length int) { 26 | cmsg.Len = uint32(length) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows && race 6 | 7 | package windows 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go: -------------------------------------------------------------------------------- 1 | //go:build testify_yaml_fail && !testify_yaml_custom && !testify_yaml_default 2 | // +build testify_yaml_fail,!testify_yaml_custom,!testify_yaml_default 3 | 4 | // Package yaml is an implementation of YAML functions that always fail. 5 | // 6 | // This implementation can be used at build time to replace the default implementation 7 | // to avoid linking with [gopkg.in/yaml.v3]: 8 | // 9 | // go test -tags testify_yaml_fail 10 | package yaml 11 | 12 | import "errors" 13 | 14 | var errNotImplemented = errors.New("YAML functions are not available (see https://pkg.go.dev/github.com/stretchr/testify/assert/yaml)") 15 | 16 | func Unmarshal([]byte, interface{}) error { 17 | return errNotImplemented 18 | } 19 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/blake2b/register.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package blake2b 6 | 7 | import ( 8 | "crypto" 9 | "hash" 10 | ) 11 | 12 | func init() { 13 | newHash256 := func() hash.Hash { 14 | h, _ := New256(nil) 15 | return h 16 | } 17 | newHash384 := func() hash.Hash { 18 | h, _ := New384(nil) 19 | return h 20 | } 21 | 22 | newHash512 := func() hash.Hash { 23 | h, _ := New512(nil) 24 | return h 25 | } 26 | 27 | crypto.RegisterHash(crypto.BLAKE2b_256, newHash256) 28 | crypto.RegisterHash(crypto.BLAKE2b_384, newHash384) 29 | crypto.RegisterHash(crypto.BLAKE2b_512, newHash512) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_loong64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2025 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | // HWCAP bits. These are exposed by the Linux kernel. 8 | const ( 9 | hwcap_LOONGARCH_LSX = 1 << 4 10 | hwcap_LOONGARCH_LASX = 1 << 5 11 | ) 12 | 13 | func doinit() { 14 | // TODO: Features that require kernel support like LSX and LASX can 15 | // be detected here once needed in std library or by the compiler. 16 | Loong64.HasLSX = hwcIsSet(hwCap, hwcap_LOONGARCH_LSX) 17 | Loong64.HasLASX = hwcIsSet(hwCap, hwcap_LOONGARCH_LASX) 18 | } 19 | 20 | func hwcIsSet(hwc uint, val uint) bool { 21 | return hwc&val != 0 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/internal/sha3/rc.go: -------------------------------------------------------------------------------- 1 | package sha3 2 | 3 | // RC stores the round constants for use in the ι step. 4 | var RC = [24]uint64{ 5 | 0x0000000000000001, 6 | 0x0000000000008082, 7 | 0x800000000000808A, 8 | 0x8000000080008000, 9 | 0x000000000000808B, 10 | 0x0000000080000001, 11 | 0x8000000080008081, 12 | 0x8000000000008009, 13 | 0x000000000000008A, 14 | 0x0000000000000088, 15 | 0x0000000080008009, 16 | 0x000000008000000A, 17 | 0x000000008000808B, 18 | 0x800000000000008B, 19 | 0x8000000000008089, 20 | 0x8000000000008003, 21 | 0x8000000000008002, 22 | 0x8000000000000080, 23 | 0x000000000000800A, 24 | 0x800000008000000A, 25 | 0x8000000080008081, 26 | 0x8000000000008080, 27 | 0x0000000080000001, 28 | 0x8000000080008008, 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (386 || amd64 || amd64p32) && gccgo 6 | 7 | package cpu 8 | 9 | //extern gccgoGetCpuidCount 10 | func gccgoGetCpuidCount(eaxArg, ecxArg uint32, eax, ebx, ecx, edx *uint32) 11 | 12 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) { 13 | var a, b, c, d uint32 14 | gccgoGetCpuidCount(eaxArg, ecxArg, &a, &b, &c, &d) 15 | return a, b, c, d 16 | } 17 | 18 | //extern gccgoXgetbv 19 | func gccgoXgetbv(eax, edx *uint32) 20 | 21 | func xgetbv() (eax, edx uint32) { 22 | var a, d uint32 23 | gccgoXgetbv(&a, &d) 24 | return a, d 25 | } 26 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | name: Release 2 | 3 | on: 4 | push: 5 | tags: 6 | - 'v*.*.*' 7 | 8 | jobs: 9 | release: 10 | runs-on: ubuntu-latest 11 | 12 | steps: 13 | - name: Checkout repository 14 | uses: actions/checkout@v4 15 | 16 | - name: Set up Go 17 | uses: actions/setup-go@v5 18 | with: 19 | go-version: 1.22 20 | 21 | - name: Build 22 | run: | 23 | mkdir -p dist 24 | 25 | GOOS=darwin GOARCH=amd64 go build -o dist/fleet-darwin-amd64 . 26 | 27 | 28 | - name: Upload release to GitHub 29 | uses: softprops/action-gh-release@v2 30 | with: 31 | files: dist/* 32 | env: 33 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_aix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix 6 | 7 | package cpu 8 | 9 | const ( 10 | // getsystemcfg constants 11 | _SC_IMPL = 2 12 | _IMPL_POWER8 = 0x10000 13 | _IMPL_POWER9 = 0x20000 14 | ) 15 | 16 | func archInit() { 17 | impl := getsystemcfg(_SC_IMPL) 18 | if impl&_IMPL_POWER8 != 0 { 19 | PPC64.IsPOWER8 = true 20 | } 21 | if impl&_IMPL_POWER9 != 0 { 22 | PPC64.IsPOWER8 = true 23 | PPC64.IsPOWER9 = true 24 | } 25 | 26 | Initialized = true 27 | } 28 | 29 | func getsystemcfg(label int) (n uint64) { 30 | r0, _ := callgetsystemcfg(label) 31 | n = uint64(r0) 32 | return 33 | } 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | func initS390Xbase() { 8 | // get the facilities list 9 | facilities := stfle() 10 | 11 | // mandatory 12 | S390X.HasZARCH = facilities.Has(zarch) 13 | S390X.HasSTFLE = facilities.Has(stflef) 14 | S390X.HasLDISP = facilities.Has(ldisp) 15 | S390X.HasEIMM = facilities.Has(eimm) 16 | 17 | // optional 18 | S390X.HasETF3EH = facilities.Has(etf3eh) 19 | S390X.HasDFP = facilities.Has(dfp) 20 | S390X.HasMSA = facilities.Has(msa) 21 | S390X.HasVX = facilities.Has(vx) 22 | if S390X.HasVX { 23 | S390X.HasVXE = facilities.Has(vxe) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/internal/path_util/path_util.go: -------------------------------------------------------------------------------- 1 | package path_util 2 | 3 | import ( 4 | "os" 5 | "os/user" 6 | "strings" 7 | ) 8 | 9 | func ReplaceTildeWithHome(path string) (string, error) { 10 | if strings.HasPrefix(path, "~") { 11 | firstSlash := strings.Index(path, "/") 12 | if firstSlash == 1 { 13 | home, err := os.UserHomeDir() 14 | if err != nil { 15 | return path, err 16 | } 17 | return strings.Replace(path, "~", home, 1), nil 18 | } else if firstSlash > 1 { 19 | username := path[1:firstSlash] 20 | userAccount, err := user.Lookup(username) 21 | if err != nil { 22 | return path, err 23 | } 24 | return strings.Replace(path, path[:firstSlash], userAccount.HomeDir, 1), nil 25 | } 26 | } 27 | 28 | return path, nil 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/error.go: -------------------------------------------------------------------------------- 1 | package plumbing 2 | 3 | import "fmt" 4 | 5 | type PermanentError struct { 6 | Err error 7 | } 8 | 9 | func NewPermanentError(err error) *PermanentError { 10 | if err == nil { 11 | return nil 12 | } 13 | 14 | return &PermanentError{Err: err} 15 | } 16 | 17 | func (e *PermanentError) Error() string { 18 | return fmt.Sprintf("permanent client error: %s", e.Err.Error()) 19 | } 20 | 21 | type UnexpectedError struct { 22 | Err error 23 | } 24 | 25 | func NewUnexpectedError(err error) *UnexpectedError { 26 | if err == nil { 27 | return nil 28 | } 29 | 30 | return &UnexpectedError{Err: err} 31 | } 32 | 33 | func (e *UnexpectedError) Error() string { 34 | return fmt.Sprintf("unexpected client error: %s", e.Err.Error()) 35 | } 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin && race) || (linux && race) || (freebsd && race) 6 | 7 | package unix 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/hash.go: -------------------------------------------------------------------------------- 1 | package openpgp 2 | 3 | import ( 4 | "crypto" 5 | 6 | "github.com/ProtonMail/go-crypto/openpgp/internal/algorithm" 7 | ) 8 | 9 | // HashIdToHash returns a crypto.Hash which corresponds to the given OpenPGP 10 | // hash id. 11 | func HashIdToHash(id byte) (h crypto.Hash, ok bool) { 12 | return algorithm.HashIdToHash(id) 13 | } 14 | 15 | // HashIdToString returns the name of the hash function corresponding to the 16 | // given OpenPGP hash id. 17 | func HashIdToString(id byte) (name string, ok bool) { 18 | return algorithm.HashIdToString(id) 19 | } 20 | 21 | // HashToHashId returns an OpenPGP hash id which corresponds the given Hash. 22 | func HashToHashId(h crypto.Hash) (id byte, ok bool) { 23 | return algorithm.HashToHashId(h) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | package cpu 8 | 9 | // haveAsmFunctions reports whether the other functions in this file can 10 | // be safely called. 11 | func haveAsmFunctions() bool { return true } 12 | 13 | // The following feature detection functions are defined in cpu_s390x.s. 14 | // They are likely to be expensive to call so the results should be cached. 15 | func stfle() facilityList 16 | func kmQuery() queryResult 17 | func kmcQuery() queryResult 18 | func kmctrQuery() queryResult 19 | func kmaQuery() queryResult 20 | func kimdQuery() queryResult 21 | func klmdQuery() queryResult 22 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/command_notwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013-2023 The Cobra Authors 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | //go:build !windows 16 | // +build !windows 17 | 18 | package cobra 19 | 20 | var preExecHookFn func(*Command) 21 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/utils/sync/bufio.go: -------------------------------------------------------------------------------- 1 | package sync 2 | 3 | import ( 4 | "bufio" 5 | "io" 6 | "sync" 7 | ) 8 | 9 | var bufioReader = sync.Pool{ 10 | New: func() interface{} { 11 | return bufio.NewReader(nil) 12 | }, 13 | } 14 | 15 | // GetBufioReader returns a *bufio.Reader that is managed by a sync.Pool. 16 | // Returns a bufio.Reader that is reset with reader and ready for use. 17 | // 18 | // After use, the *bufio.Reader should be put back into the sync.Pool 19 | // by calling PutBufioReader. 20 | func GetBufioReader(reader io.Reader) *bufio.Reader { 21 | r := bufioReader.Get().(*bufio.Reader) 22 | r.Reset(reader) 23 | return r 24 | } 25 | 26 | // PutBufioReader puts reader back into its sync.Pool. 27 | func PutBufioReader(reader *bufio.Reader) { 28 | bufioReader.Put(reader) 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/env_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | // Unix environment variables. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getenv(key string) (value string, found bool) { 14 | return syscall.Getenv(key) 15 | } 16 | 17 | func Setenv(key, value string) error { 18 | return syscall.Setenv(key, value) 19 | } 20 | 21 | func Clearenv() { 22 | syscall.Clearenv() 23 | } 24 | 25 | func Environ() []string { 26 | return syscall.Environ() 27 | } 28 | 29 | func Unsetenv(key string) error { 30 | return syscall.Unsetenv(key) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_hurd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build hurd 6 | 7 | package unix 8 | 9 | /* 10 | #include 11 | int ioctl(int, unsigned long int, uintptr_t); 12 | */ 13 | import "C" 14 | import "unsafe" 15 | 16 | func ioctl(fd int, req uint, arg uintptr) (err error) { 17 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) 18 | if r0 == -1 && er != nil { 19 | err = er 20 | } 21 | return 22 | } 23 | 24 | func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { 25 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(uintptr(arg))) 26 | if r0 == -1 && er != nil { 27 | err = er 28 | } 29 | return 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | B syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | B syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | B syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | B syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | B syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/readdirent_getdirentries.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin || zos 6 | 7 | package unix 8 | 9 | import "unsafe" 10 | 11 | // ReadDirent reads directory entries from fd and writes them into buf. 12 | func ReadDirent(fd int, buf []byte) (n int, err error) { 13 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. 14 | // 64 bits should be enough. (32 bits isn't even on 386). Since the 15 | // actual system call is getdirentries64, 64 is a good guess. 16 | // TODO(rsc): Can we use a single global basep for all calls? 17 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) 18 | return Getdirentries(fd, buf, base) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zptrace_linux_arm64.go: -------------------------------------------------------------------------------- 1 | // Code generated by linux/mkall.go generatePtraceRegSet("arm64"). DO NOT EDIT. 2 | 3 | package unix 4 | 5 | import "unsafe" 6 | 7 | // PtraceGetRegSetArm64 fetches the registers used by arm64 binaries. 8 | func PtraceGetRegSetArm64(pid, addr int, regsout *PtraceRegsArm64) error { 9 | iovec := Iovec{(*byte)(unsafe.Pointer(regsout)), uint64(unsafe.Sizeof(*regsout))} 10 | return ptracePtr(PTRACE_GETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 11 | } 12 | 13 | // PtraceSetRegSetArm64 sets the registers used by arm64 binaries. 14 | func PtraceSetRegSetArm64(pid, addr int, regs *PtraceRegsArm64) error { 15 | iovec := Iovec{(*byte)(unsafe.Pointer(regs)), uint64(unsafe.Sizeof(*regs))} 16 | return ptracePtr(PTRACE_SETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for mips64, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/github.com/emirpasic/gods/containers/serialization.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2015, Emir Pasic. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package containers 6 | 7 | // JSONSerializer provides JSON serialization 8 | type JSONSerializer interface { 9 | // ToJSON outputs the JSON representation of containers's elements. 10 | ToJSON() ([]byte, error) 11 | // MarshalJSON @implements json.Marshaler 12 | MarshalJSON() ([]byte, error) 13 | } 14 | 15 | // JSONDeserializer provides JSON deserialization 16 | type JSONDeserializer interface { 17 | // FromJSON populates containers's elements from the input JSON representation. 18 | FromJSON([]byte) error 19 | // UnmarshalJSON @implements json.Unmarshaler 20 | UnmarshalJSON([]byte) error 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/format/packfile/error.go: -------------------------------------------------------------------------------- 1 | package packfile 2 | 3 | import "fmt" 4 | 5 | // Error specifies errors returned during packfile parsing. 6 | type Error struct { 7 | reason, details string 8 | } 9 | 10 | // NewError returns a new error. 11 | func NewError(reason string) *Error { 12 | return &Error{reason: reason} 13 | } 14 | 15 | // Error returns a text representation of the error. 16 | func (e *Error) Error() string { 17 | if e.details == "" { 18 | return e.reason 19 | } 20 | 21 | return fmt.Sprintf("%s: %s", e.reason, e.details) 22 | } 23 | 24 | // AddDetails adds details to an error, with additional text. 25 | func (e *Error) AddDetails(format string, args ...interface{}) *Error { 26 | return &Error{ 27 | reason: e.reason, 28 | details: fmt.Sprintf(format, args...), 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for 386 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x448/curve_amd64.go: -------------------------------------------------------------------------------- 1 | //go:build amd64 && !purego 2 | // +build amd64,!purego 3 | 4 | package x448 5 | 6 | import ( 7 | fp "github.com/cloudflare/circl/math/fp448" 8 | "golang.org/x/sys/cpu" 9 | ) 10 | 11 | var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX 12 | 13 | var _ = hasBmi2Adx 14 | 15 | func double(x, z *fp.Elt) { doubleAmd64(x, z) } 16 | func diffAdd(w *[5]fp.Elt, b uint) { diffAddAmd64(w, b) } 17 | func ladderStep(w *[5]fp.Elt, b uint) { ladderStepAmd64(w, b) } 18 | func mulA24(z, x *fp.Elt) { mulA24Amd64(z, x) } 19 | 20 | //go:noescape 21 | func doubleAmd64(x, z *fp.Elt) 22 | 23 | //go:noescape 24 | func diffAddAmd64(w *[5]fp.Elt, b uint) 25 | 26 | //go:noescape 27 | func ladderStepAmd64(w *[5]fp.Elt, b uint) 28 | 29 | //go:noescape 30 | func mulA24Amd64(z, x *fp.Elt) 31 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/storage/filesystem/deltaobject.go: -------------------------------------------------------------------------------- 1 | package filesystem 2 | 3 | import ( 4 | "github.com/go-git/go-git/v5/plumbing" 5 | ) 6 | 7 | type deltaObject struct { 8 | plumbing.EncodedObject 9 | base plumbing.Hash 10 | hash plumbing.Hash 11 | size int64 12 | } 13 | 14 | func newDeltaObject( 15 | obj plumbing.EncodedObject, 16 | hash plumbing.Hash, 17 | base plumbing.Hash, 18 | size int64) plumbing.DeltaObject { 19 | return &deltaObject{ 20 | EncodedObject: obj, 21 | hash: hash, 22 | base: base, 23 | size: size, 24 | } 25 | } 26 | 27 | func (o *deltaObject) BaseHash() plumbing.Hash { 28 | return o.base 29 | } 30 | 31 | func (o *deltaObject) ActualSize() int64 { 32 | return o.size 33 | } 34 | 35 | func (o *deltaObject) ActualHash() plumbing.Hash { 36 | return o.hash 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/davecgh/go-spew/LICENSE: -------------------------------------------------------------------------------- 1 | ISC License 2 | 3 | Copyright (c) 2012-2016 Dave Collins 4 | 5 | Permission to use, copy, modify, and/or distribute this software for any 6 | purpose with or without fee is hereby granted, provided that the above 7 | copyright notice and this permission notice appear in all copies. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_riscv64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for RISCV64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/internal/socket/rawaddr.go: -------------------------------------------------------------------------------- 1 | package socket 2 | 3 | import ( 4 | "unsafe" 5 | ) 6 | 7 | // RawSockaddr allows structs to be used with [Bind] and [ConnectEx]. The 8 | // struct must meet the Win32 sockaddr requirements specified here: 9 | // https://docs.microsoft.com/en-us/windows/win32/winsock/sockaddr-2 10 | // 11 | // Specifically, the struct size must be least larger than an int16 (unsigned short) 12 | // for the address family. 13 | type RawSockaddr interface { 14 | // Sockaddr returns a pointer to the RawSockaddr and its struct size, allowing 15 | // for the RawSockaddr's data to be overwritten by syscalls (if necessary). 16 | // 17 | // It is the callers responsibility to validate that the values are valid; invalid 18 | // pointers or size can cause a panic. 19 | Sockaddr() (unsafe.Pointer, int32, error) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x25519/curve_amd64.go: -------------------------------------------------------------------------------- 1 | //go:build amd64 && !purego 2 | // +build amd64,!purego 3 | 4 | package x25519 5 | 6 | import ( 7 | fp "github.com/cloudflare/circl/math/fp25519" 8 | "golang.org/x/sys/cpu" 9 | ) 10 | 11 | var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX 12 | 13 | var _ = hasBmi2Adx 14 | 15 | func double(x, z *fp.Elt) { doubleAmd64(x, z) } 16 | func diffAdd(w *[5]fp.Elt, b uint) { diffAddAmd64(w, b) } 17 | func ladderStep(w *[5]fp.Elt, b uint) { ladderStepAmd64(w, b) } 18 | func mulA24(z, x *fp.Elt) { mulA24Amd64(z, x) } 19 | 20 | //go:noescape 21 | func ladderStepAmd64(w *[5]fp.Elt, b uint) 22 | 23 | //go:noescape 24 | func diffAddAmd64(w *[5]fp.Elt, b uint) 25 | 26 | //go:noescape 27 | func doubleAmd64(x, z *fp.Elt) 28 | 29 | //go:noescape 30 | func mulA24Amd64(z, x *fp.Elt) 31 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/position.go: -------------------------------------------------------------------------------- 1 | package ssh_config 2 | 3 | import "fmt" 4 | 5 | // Position of a document element within a SSH document. 6 | // 7 | // Line and Col are both 1-indexed positions for the element's line number and 8 | // column number, respectively. Values of zero or less will cause Invalid(), 9 | // to return true. 10 | type Position struct { 11 | Line int // line within the document 12 | Col int // column within the line 13 | } 14 | 15 | // String representation of the position. 16 | // Displays 1-indexed line and column numbers. 17 | func (p Position) String() string { 18 | return fmt.Sprintf("(%d, %d)", p.Line, p.Col) 19 | } 20 | 21 | // Invalid returns whether or not the position is valid (i.e. with negative or 22 | // null values) 23 | func (p Position) Invalid() bool { 24 | return p.Line <= 0 || p.Col <= 0 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for AMD64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/packet/notation.go: -------------------------------------------------------------------------------- 1 | package packet 2 | 3 | // Notation type represents a Notation Data subpacket 4 | // see https://tools.ietf.org/html/rfc4880#section-5.2.3.16 5 | type Notation struct { 6 | Name string 7 | Value []byte 8 | IsCritical bool 9 | IsHumanReadable bool 10 | } 11 | 12 | func (notation *Notation) getData() []byte { 13 | nameData := []byte(notation.Name) 14 | nameLen := len(nameData) 15 | valueLen := len(notation.Value) 16 | 17 | data := make([]byte, 8+nameLen+valueLen) 18 | if notation.IsHumanReadable { 19 | data[0] = 0x80 20 | } 21 | 22 | data[4] = byte(nameLen >> 8) 23 | data[5] = byte(nameLen) 24 | data[6] = byte(valueLen >> 8) 25 | data[7] = byte(valueLen) 26 | copy(data[8:8+nameLen], nameData) 27 | copy(data[8+nameLen:], notation.Value) 28 | return data 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ppc64, BSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Recreate a getsystemcfg syscall handler instead of 6 | // using the one provided by x/sys/unix to avoid having 7 | // the dependency between them. (See golang.org/issue/32102) 8 | // Moreover, this file will be used during the building of 9 | // gccgo's libgo and thus must not used a CGo method. 10 | 11 | //go:build aix && gccgo 12 | 13 | package cpu 14 | 15 | import ( 16 | "syscall" 17 | ) 18 | 19 | //extern getsystemcfg 20 | func gccgoGetsystemcfg(label uint32) (r uint64) 21 | 22 | func callgetsystemcfg(label int) (r1 uintptr, e1 syscall.Errno) { 23 | r1 = uintptr(gccgoGetsystemcfg(uint32(label))) 24 | e1 = syscall.GetErrno() 25 | return 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/bluetooth_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Bluetooth sockets and messages 6 | 7 | package unix 8 | 9 | // Bluetooth Protocols 10 | const ( 11 | BTPROTO_L2CAP = 0 12 | BTPROTO_HCI = 1 13 | BTPROTO_SCO = 2 14 | BTPROTO_RFCOMM = 3 15 | BTPROTO_BNEP = 4 16 | BTPROTO_CMTP = 5 17 | BTPROTO_HIDP = 6 18 | BTPROTO_AVDTP = 7 19 | ) 20 | 21 | const ( 22 | HCI_CHANNEL_RAW = 0 23 | HCI_CHANNEL_USER = 1 24 | HCI_CHANNEL_MONITOR = 2 25 | HCI_CHANNEL_CONTROL = 3 26 | HCI_CHANNEL_LOGGING = 4 27 | ) 28 | 29 | // Socketoption Level 30 | const ( 31 | SOL_BLUETOOTH = 0x112 32 | SOL_HCI = 0x0 33 | SOL_L2CAP = 0x6 34 | SOL_RFCOMM = 0x12 35 | SOL_SCO = 0x11 36 | ) 37 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/packet/padding.go: -------------------------------------------------------------------------------- 1 | package packet 2 | 3 | import ( 4 | "io" 5 | ) 6 | 7 | // Padding type represents a Padding Packet (Tag 21). 8 | // The padding type is represented by the length of its padding. 9 | // see https://datatracker.ietf.org/doc/html/draft-ietf-openpgp-crypto-refresh#name-padding-packet-tag-21 10 | type Padding int 11 | 12 | // parse just ignores the padding content. 13 | func (pad Padding) parse(reader io.Reader) error { 14 | _, err := io.CopyN(io.Discard, reader, int64(pad)) 15 | return err 16 | } 17 | 18 | // SerializePadding writes the padding to writer. 19 | func (pad Padding) SerializePadding(writer io.Writer, rand io.Reader) error { 20 | err := serializeHeader(writer, packetPadding, int(pad)) 21 | if err != nil { 22 | return err 23 | } 24 | _, err = io.CopyN(writer, rand, int64(pad)) 25 | return err 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_aix_ppc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix && ppc 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by AIX. 9 | 10 | package unix 11 | 12 | // Major returns the major component of a Linux device number. 13 | func Major(dev uint64) uint32 { 14 | return uint32((dev >> 16) & 0xffff) 15 | } 16 | 17 | // Minor returns the minor component of a Linux device number. 18 | func Minor(dev uint64) uint32 { 19 | return uint32(dev & 0xffff) 20 | } 21 | 22 | // Mkdev returns a Linux device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | return uint64(((major) << 16) | (minor)) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in Darwin's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a Darwin device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev >> 24) & 0xff) 13 | } 14 | 15 | // Minor returns the minor component of a Darwin device number. 16 | func Minor(dev uint64) uint32 { 17 | return uint32(dev & 0xffffff) 18 | } 19 | 20 | // Mkdev returns a Darwin device number generated from the given major and minor 21 | // components. 22 | func Mkdev(major, minor uint32) uint64 { 23 | return (uint64(major) << 24) | uint64(minor) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x448/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package x448 provides Diffie-Hellman functions as specified in RFC-7748. 3 | 4 | Validation of public keys. 5 | 6 | The Diffie-Hellman function, as described in RFC-7748 [1], works for any 7 | public key. However, if a different protocol requires contributory 8 | behaviour [2,3], then the public keys must be validated against low-order 9 | points [3,4]. To do that, the Shared function performs this validation 10 | internally and returns false when the public key is invalid (i.e., it 11 | is a low-order point). 12 | 13 | References: 14 | - [1] RFC7748 by Langley, Hamburg, Turner (https://rfc-editor.org/rfc/rfc7748.txt) 15 | - [2] Curve25519 by Bernstein (https://cr.yp.to/ecdh.html) 16 | - [3] Bernstein (https://cr.yp.to/ecdh.html#validate) 17 | - [4] Cremers&Jackson (https://eprint.iacr.org/2019/526) 18 | */ 19 | package x448 20 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/osfs/os_posix.go: -------------------------------------------------------------------------------- 1 | //go:build !plan9 && !windows && !wasm 2 | // +build !plan9,!windows,!wasm 3 | 4 | package osfs 5 | 6 | import ( 7 | "os" 8 | "syscall" 9 | 10 | "golang.org/x/sys/unix" 11 | ) 12 | 13 | func (f *file) Lock() error { 14 | f.m.Lock() 15 | defer f.m.Unlock() 16 | 17 | return unix.Flock(int(f.File.Fd()), unix.LOCK_EX) 18 | } 19 | 20 | func (f *file) Unlock() error { 21 | f.m.Lock() 22 | defer f.m.Unlock() 23 | 24 | return unix.Flock(int(f.File.Fd()), unix.LOCK_UN) 25 | } 26 | 27 | func rename(from, to string) error { 28 | return os.Rename(from, to) 29 | } 30 | 31 | // umask sets umask to a new value, and returns a func which allows the 32 | // caller to reset it back to what it was originally. 33 | func umask(new int) func() { 34 | old := syscall.Umask(new) 35 | return func() { 36 | syscall.Umask(old) 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/Makefile: -------------------------------------------------------------------------------- 1 | BUMP_VERSION := $(GOPATH)/bin/bump_version 2 | STATICCHECK := $(GOPATH)/bin/staticcheck 3 | WRITE_MAILMAP := $(GOPATH)/bin/write_mailmap 4 | 5 | $(STATICCHECK): 6 | go get honnef.co/go/tools/cmd/staticcheck 7 | 8 | lint: $(STATICCHECK) 9 | go vet ./... 10 | $(STATICCHECK) 11 | 12 | test: lint 13 | @# the timeout helps guard against infinite recursion 14 | go test -timeout=250ms ./... 15 | 16 | race-test: lint 17 | go test -timeout=500ms -race ./... 18 | 19 | $(BUMP_VERSION): 20 | go get -u github.com/kevinburke/bump_version 21 | 22 | $(WRITE_MAILMAP): 23 | go get -u github.com/kevinburke/write_mailmap 24 | 25 | release: test | $(BUMP_VERSION) 26 | $(BUMP_VERSION) --tag-prefix=v minor config.go 27 | 28 | force: ; 29 | 30 | AUTHORS.txt: force | $(WRITE_MAILMAP) 31 | $(WRITE_MAILMAP) > AUTHORS.txt 32 | 33 | authors: AUTHORS.txt 34 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x25519/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package x25519 provides Diffie-Hellman functions as specified in RFC-7748. 3 | 4 | Validation of public keys. 5 | 6 | The Diffie-Hellman function, as described in RFC-7748 [1], works for any 7 | public key. However, if a different protocol requires contributory 8 | behaviour [2,3], then the public keys must be validated against low-order 9 | points [3,4]. To do that, the Shared function performs this validation 10 | internally and returns false when the public key is invalid (i.e., it 11 | is a low-order point). 12 | 13 | References: 14 | - [1] RFC7748 by Langley, Hamburg, Turner (https://rfc-editor.org/rfc/rfc7748.txt) 15 | - [2] Curve25519 by Bernstein (https://cr.yp.to/ecdh.html) 16 | - [3] Bernstein (https://cr.yp.to/ecdh.html#validate) 17 | - [4] Cremers&Jackson (https://eprint.iacr.org/2019/526) 18 | */ 19 | package x25519 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego 6 | 7 | package chacha20 8 | 9 | import "golang.org/x/sys/cpu" 10 | 11 | var haveAsm = cpu.S390X.HasVX 12 | 13 | const bufSize = 256 14 | 15 | // xorKeyStreamVX is an assembly implementation of XORKeyStream. It must only 16 | // be called when the vector facility is available. Implementation in asm_s390x.s. 17 | // 18 | //go:noescape 19 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32) 20 | 21 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 22 | if cpu.S390X.HasVX { 23 | xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter) 24 | } else { 25 | c.xorKeyStreamBlocksGeneric(dst, src) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/packet/marker.go: -------------------------------------------------------------------------------- 1 | package packet 2 | 3 | import ( 4 | "io" 5 | 6 | "github.com/ProtonMail/go-crypto/openpgp/errors" 7 | ) 8 | 9 | type Marker struct{} 10 | 11 | const markerString = "PGP" 12 | 13 | // parse just checks if the packet contains "PGP". 14 | func (m *Marker) parse(reader io.Reader) error { 15 | var buffer [3]byte 16 | if _, err := io.ReadFull(reader, buffer[:]); err != nil { 17 | return err 18 | } 19 | if string(buffer[:]) != markerString { 20 | return errors.StructuralError("invalid marker packet") 21 | } 22 | return nil 23 | } 24 | 25 | // SerializeMarker writes a marker packet to writer. 26 | func SerializeMarker(writer io.Writer) error { 27 | err := serializeHeader(writer, packetTypeMarker, len(markerString)) 28 | if err != nil { 29 | return err 30 | } 31 | _, err = writer.Write([]byte(markerString)) 32 | return err 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/internal/encoding/encoding.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package encoding implements openpgp packet field encodings as specified in 6 | // RFC 4880 and 6637. 7 | package encoding 8 | 9 | import "io" 10 | 11 | // Field is an encoded field of an openpgp packet. 12 | type Field interface { 13 | // Bytes returns the decoded data. 14 | Bytes() []byte 15 | 16 | // BitLength is the size in bits of the decoded data. 17 | BitLength() uint16 18 | 19 | // EncodedBytes returns the encoded data. 20 | EncodedBytes() []byte 21 | 22 | // EncodedLength is the size in bytes of the encoded data. 23 | EncodedLength() uint16 24 | 25 | // ReadFrom reads the next Field from r. 26 | ReadFrom(r io.Reader) (int64, error) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/cyphar/filepath-securejoin/gocompat_generics_go121.go: -------------------------------------------------------------------------------- 1 | //go:build linux && go1.21 2 | 3 | // Copyright (C) 2024 SUSE LLC. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | package securejoin 8 | 9 | import ( 10 | "slices" 11 | "sync" 12 | ) 13 | 14 | func slices_DeleteFunc[S ~[]E, E any](slice S, delFn func(E) bool) S { 15 | return slices.DeleteFunc(slice, delFn) 16 | } 17 | 18 | func slices_Contains[S ~[]E, E comparable](slice S, val E) bool { 19 | return slices.Contains(slice, val) 20 | } 21 | 22 | func slices_Clone[S ~[]E, E any](slice S) S { 23 | return slices.Clone(slice) 24 | } 25 | 26 | func sync_OnceValue[T any](f func() T) func() T { 27 | return sync.OnceValue(f) 28 | } 29 | 30 | func sync_OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2) { 31 | return sync.OnceValues(f) 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/pkg/guid/variant_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Variant -trimprefix=Variant -linecomment"; DO NOT EDIT. 2 | 3 | package guid 4 | 5 | import "strconv" 6 | 7 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[VariantUnknown-0] 12 | _ = x[VariantNCS-1] 13 | _ = x[VariantRFC4122-2] 14 | _ = x[VariantMicrosoft-3] 15 | _ = x[VariantFuture-4] 16 | } 17 | 18 | const _Variant_name = "UnknownNCSRFC 4122MicrosoftFuture" 19 | 20 | var _Variant_index = [...]uint8{0, 7, 10, 18, 27, 33} 21 | 22 | func (i Variant) String() string { 23 | if i >= Variant(len(_Variant_index)-1) { 24 | return "Variant(" + strconv.FormatInt(int64(i), 10) + ")" 25 | } 26 | return _Variant_name[_Variant_index[i]:_Variant_index[i+1]] 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/emirpasic/gods/trees/trees.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2015, Emir Pasic. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package trees provides an abstract Tree interface. 6 | // 7 | // In computer science, a tree is a widely used abstract data type (ADT) or data structure implementing this ADT that simulates a hierarchical tree structure, with a root value and subtrees of children with a parent node, represented as a set of linked nodes. 8 | // 9 | // Reference: https://en.wikipedia.org/wiki/Tree_%28data_structure%29 10 | package trees 11 | 12 | import "github.com/emirpasic/gods/containers" 13 | 14 | // Tree interface that all trees implement 15 | type Tree interface { 16 | containers.Container 17 | // Empty() bool 18 | // Size() int 19 | // Clear() 20 | // Values() []interface{} 21 | // String() string 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64le || ppc64) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 12 | return syscall.Syscall(trap, a1, a2, a3) 13 | } 14 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 15 | return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6) 16 | } 17 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 18 | return syscall.RawSyscall(trap, a1, a2, a3) 19 | } 20 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 21 | return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/emirpasic/gods/utils/sort.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2015, Emir Pasic. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package utils 6 | 7 | import "sort" 8 | 9 | // Sort sorts values (in-place) with respect to the given comparator. 10 | // 11 | // Uses Go's sort (hybrid of quicksort for large and then insertion sort for smaller slices). 12 | func Sort(values []interface{}, comparator Comparator) { 13 | sort.Sort(sortable{values, comparator}) 14 | } 15 | 16 | type sortable struct { 17 | values []interface{} 18 | comparator Comparator 19 | } 20 | 21 | func (s sortable) Len() int { 22 | return len(s.values) 23 | } 24 | func (s sortable) Swap(i, j int) { 25 | s.values[i], s.values[j] = s.values[j], s.values[i] 26 | } 27 | func (s sortable) Less(i, j int) bool { 28 | return s.comparator(s.values[i], s.values[j]) < 0 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package git 4 | 5 | import ( 6 | "os" 7 | "syscall" 8 | "time" 9 | 10 | "github.com/go-git/go-git/v5/plumbing/format/index" 11 | ) 12 | 13 | func init() { 14 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 15 | if os, ok := sys.(*syscall.Win32FileAttributeData); ok { 16 | seconds := os.CreationTime.Nanoseconds() / 1000000000 17 | nanoseconds := os.CreationTime.Nanoseconds() - seconds*1000000000 18 | e.CreatedAt = time.Unix(seconds, nanoseconds) 19 | } 20 | } 21 | } 22 | 23 | func isSymlinkWindowsNonAdmin(err error) bool { 24 | const ERROR_PRIVILEGE_NOT_HELD syscall.Errno = 1314 25 | 26 | if err != nil { 27 | if errLink, ok := err.(*os.LinkError); ok { 28 | if errNo, ok := errLink.Err.(syscall.Errno); ok { 29 | return errNo == ERROR_PRIVILEGE_NOT_HELD 30 | } 31 | } 32 | } 33 | 34 | return false 35 | } 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fdset.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | // Set adds fd to the set fds. 10 | func (fds *FdSet) Set(fd int) { 11 | fds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS)) 12 | } 13 | 14 | // Clear removes fd from the set fds. 15 | func (fds *FdSet) Clear(fd int) { 16 | fds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS)) 17 | } 18 | 19 | // IsSet returns whether fd is in the set fds. 20 | func (fds *FdSet) IsSet(fd int) bool { 21 | return fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0 22 | } 23 | 24 | // Zero clears the set fds. 25 | func (fds *FdSet) Zero() { 26 | for i := range fds.Bits { 27 | fds.Bits[i] = 0 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64 || ppc64le) 6 | 7 | package cpu 8 | 9 | // HWCAP/HWCAP2 bits. These are exposed by the kernel. 10 | const ( 11 | // ISA Level 12 | _PPC_FEATURE2_ARCH_2_07 = 0x80000000 13 | _PPC_FEATURE2_ARCH_3_00 = 0x00800000 14 | 15 | // CPU features 16 | _PPC_FEATURE2_DARN = 0x00200000 17 | _PPC_FEATURE2_SCV = 0x00100000 18 | ) 19 | 20 | func doinit() { 21 | // HWCAP2 feature bits 22 | PPC64.IsPOWER8 = isSet(hwCap2, _PPC_FEATURE2_ARCH_2_07) 23 | PPC64.IsPOWER9 = isSet(hwCap2, _PPC_FEATURE2_ARCH_3_00) 24 | PPC64.HasDARN = isSet(hwCap2, _PPC_FEATURE2_DARN) 25 | PPC64.HasSCV = isSet(hwCap2, _PPC_FEATURE2_SCV) 26 | } 27 | 28 | func isSet(hwc uint, value uint) bool { 29 | return hwc&value != 0 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | import "unsafe" 8 | 9 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument. 10 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) { 11 | return fcntl(int(fd), cmd, arg) 12 | } 13 | 14 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 15 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 16 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk)))) 17 | return err 18 | } 19 | 20 | // FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command. 21 | func FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error { 22 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore)))) 23 | return err 24 | } 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/eventlog.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | const ( 10 | EVENTLOG_SUCCESS = 0 11 | EVENTLOG_ERROR_TYPE = 1 12 | EVENTLOG_WARNING_TYPE = 2 13 | EVENTLOG_INFORMATION_TYPE = 4 14 | EVENTLOG_AUDIT_SUCCESS = 8 15 | EVENTLOG_AUDIT_FAILURE = 16 16 | ) 17 | 18 | //sys RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW 19 | //sys DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource 20 | //sys ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW 21 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/Makefile: -------------------------------------------------------------------------------- 1 | FUZZ_TIME ?= 1m 2 | 3 | export CGO_ENABLED := 1 4 | 5 | .PHONY: test 6 | test: 7 | go test ./... 8 | 9 | .PHONY: bench 10 | bench: 11 | go test -benchmem -run=^$$ -bench ^Benchmark ./... 12 | 13 | .PHONY: fuzz 14 | fuzz: 15 | go test -tags gofuzz -fuzz=. -fuzztime=$(FUZZ_TIME) ./test/ 16 | 17 | # Cross build project in arm/v7. 18 | build-arm: 19 | docker build -t sha1cd-arm -f Dockerfile.arm . 20 | docker run --rm sha1cd-arm 21 | 22 | # Cross build project in arm64. 23 | build-arm64: 24 | docker build -t sha1cd-arm64 -f Dockerfile.arm64 . 25 | docker run --rm sha1cd-arm64 26 | 27 | # Build with cgo disabled. 28 | build-nocgo: 29 | CGO_ENABLED=0 go build ./cgo 30 | 31 | # Run cross-compilation to assure supported architectures. 32 | cross-build: build-arm build-arm64 build-nocgo 33 | 34 | generate: 35 | go generate -x ./... 36 | 37 | verify: generate 38 | git diff --exit-code 39 | go vet ./... 40 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go: -------------------------------------------------------------------------------- 1 | //go:build testify_yaml_custom && !testify_yaml_fail && !testify_yaml_default 2 | // +build testify_yaml_custom,!testify_yaml_fail,!testify_yaml_default 3 | 4 | // Package yaml is an implementation of YAML functions that calls a pluggable implementation. 5 | // 6 | // This implementation is selected with the testify_yaml_custom build tag. 7 | // 8 | // go test -tags testify_yaml_custom 9 | // 10 | // This implementation can be used at build time to replace the default implementation 11 | // to avoid linking with [gopkg.in/yaml.v3]. 12 | // 13 | // In your test package: 14 | // 15 | // import assertYaml "github.com/stretchr/testify/assert/yaml" 16 | // 17 | // func init() { 18 | // assertYaml.Unmarshal = func (in []byte, out interface{}) error { 19 | // // ... 20 | // return nil 21 | // } 22 | // } 23 | package yaml 24 | 25 | var Unmarshal func(in []byte, out interface{}) error 26 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/format/config/decoder.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "io" 5 | 6 | "github.com/go-git/gcfg" 7 | ) 8 | 9 | // A Decoder reads and decodes config files from an input stream. 10 | type Decoder struct { 11 | io.Reader 12 | } 13 | 14 | // NewDecoder returns a new decoder that reads from r. 15 | func NewDecoder(r io.Reader) *Decoder { 16 | return &Decoder{r} 17 | } 18 | 19 | // Decode reads the whole config from its input and stores it in the 20 | // value pointed to by config. 21 | func (d *Decoder) Decode(config *Config) error { 22 | cb := func(s string, ss string, k string, v string, bv bool) error { 23 | if ss == "" && k == "" { 24 | config.Section(s) 25 | return nil 26 | } 27 | 28 | if ss != "" && k == "" { 29 | config.Section(s).Subsection(ss) 30 | return nil 31 | } 32 | 33 | config.AddOption(s, ss, k, v) 34 | return nil 35 | } 36 | return gcfg.ReadWithCallback(d, cb) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_zos.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build zos && s390x 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by z/OS. 9 | // 10 | // The information below is extracted and adapted from macros. 11 | 12 | package unix 13 | 14 | // Major returns the major component of a z/OS device number. 15 | func Major(dev uint64) uint32 { 16 | return uint32((dev >> 16) & 0x0000FFFF) 17 | } 18 | 19 | // Minor returns the minor component of a z/OS device number. 20 | func Minor(dev uint64) uint32 { 21 | return uint32(dev & 0x0000FFFF) 22 | } 23 | 24 | // Mkdev returns a z/OS device number generated from the given major and minor 25 | // components. 26 | func Mkdev(major, minor uint32) uint64 { 27 | return (uint64(major) << 16) | uint64(minor) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/inconshreveable/mousetrap/README.md: -------------------------------------------------------------------------------- 1 | # mousetrap 2 | 3 | mousetrap is a tiny library that answers a single question. 4 | 5 | On a Windows machine, was the process invoked by someone double clicking on 6 | the executable file while browsing in explorer? 7 | 8 | ### Motivation 9 | 10 | Windows developers unfamiliar with command line tools will often "double-click" 11 | the executable for a tool. Because most CLI tools print the help and then exit 12 | when invoked without arguments, this is often very frustrating for those users. 13 | 14 | mousetrap provides a way to detect these invocations so that you can provide 15 | more helpful behavior and instructions on how to run the CLI tool. To see what 16 | this looks like, both from an organizational and a technical perspective, see 17 | https://inconshreveable.com/09-09-2014/sweat-the-small-stuff/ 18 | 19 | ### The interface 20 | 21 | The library exposes a single interface: 22 | 23 | func StartedByExplorer() (bool) 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/proxy/direct.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package proxy 6 | 7 | import ( 8 | "context" 9 | "net" 10 | ) 11 | 12 | type direct struct{} 13 | 14 | // Direct implements Dialer by making network connections directly using net.Dial or net.DialContext. 15 | var Direct = direct{} 16 | 17 | var ( 18 | _ Dialer = Direct 19 | _ ContextDialer = Direct 20 | ) 21 | 22 | // Dial directly invokes net.Dial with the supplied parameters. 23 | func (direct) Dial(network, addr string) (net.Conn, error) { 24 | return net.Dial(network, addr) 25 | } 26 | 27 | // DialContext instantiates a net.Dialer and invokes its DialContext receiver with the supplied parameters. 28 | func (direct) DialContext(ctx context.Context, network, addr string) (net.Conn, error) { 29 | var d net.Dialer 30 | return d.DialContext(ctx, network, addr) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/signer.go: -------------------------------------------------------------------------------- 1 | package git 2 | 3 | import ( 4 | "io" 5 | 6 | "github.com/go-git/go-git/v5/plumbing" 7 | ) 8 | 9 | // signableObject is an object which can be signed. 10 | type signableObject interface { 11 | EncodeWithoutSignature(o plumbing.EncodedObject) error 12 | } 13 | 14 | // Signer is an interface for signing git objects. 15 | // message is a reader containing the encoded object to be signed. 16 | // Implementors should return the encoded signature and an error if any. 17 | // See https://git-scm.com/docs/gitformat-signature for more information. 18 | type Signer interface { 19 | Sign(message io.Reader) ([]byte, error) 20 | } 21 | 22 | func signObject(signer Signer, obj signableObject) ([]byte, error) { 23 | encoded := &plumbing.MemoryObject{} 24 | if err := obj.EncodeWithoutSignature(encoded); err != nil { 25 | return nil, err 26 | } 27 | r, err := encoded.Reader() 28 | if err != nil { 29 | return nil, err 30 | } 31 | 32 | return signer.Sign(r) 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/s2k/s2k_cache.go: -------------------------------------------------------------------------------- 1 | package s2k 2 | 3 | // Cache stores keys derived with s2k functions from one passphrase 4 | // to avoid recomputation if multiple items are encrypted with 5 | // the same parameters. 6 | type Cache map[Params][]byte 7 | 8 | // GetOrComputeDerivedKey tries to retrieve the key 9 | // for the given s2k parameters from the cache. 10 | // If there is no hit, it derives the key with the s2k function from the passphrase, 11 | // updates the cache, and returns the key. 12 | func (c *Cache) GetOrComputeDerivedKey(passphrase []byte, params *Params, expectedKeySize int) ([]byte, error) { 13 | key, found := (*c)[*params] 14 | if !found || len(key) != expectedKeySize { 15 | var err error 16 | derivedKey := make([]byte, expectedKeySize) 17 | s2k, err := params.Function() 18 | if err != nil { 19 | return nil, err 20 | } 21 | s2k(derivedKey, passphrase) 22 | (*c)[*params] = key 23 | return derivedKey, nil 24 | } 25 | return key, nil 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /internal/cli/cmd/simulate.go: -------------------------------------------------------------------------------- 1 | package cmd 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/DiegoDev2/Fleet/internal/core/manifest" 7 | "github.com/DiegoDev2/Fleet/internal/handlers" 8 | "github.com/spf13/cobra" 9 | ) 10 | 11 | func NewSimulateCmd() *cobra.Command { 12 | return &cobra.Command{ 13 | Use: "simulate [manifest-file]", 14 | Short: "Simulate installation from a manifest file", 15 | Args: cobra.ExactArgs(1), 16 | RunE: func(cmd *cobra.Command, args []string) error { 17 | manifestPath := args[0] 18 | 19 | m, err := manifest.ParseFile(manifestPath) 20 | if err != nil { 21 | return fmt.Errorf("error parsing manifest: %w", err) 22 | } 23 | 24 | errors := manifest.Validate(m) 25 | if len(errors) > 0 { 26 | fmt.Println("Manifest validation errors:") 27 | for _, err := range errors { 28 | fmt.Printf(" - %s\n", err.Error()) 29 | } 30 | return fmt.Errorf("invalid manifest") 31 | } 32 | 33 | return handlers.SimulateInstall(m) 34 | }, 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/internal/sha3/xor_generic.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!amd64 || appengine) && (!386 || appengine) && (!ppc64le || appengine) 6 | // +build !amd64 appengine 7 | // +build !386 appengine 8 | // +build !ppc64le appengine 9 | 10 | package sha3 11 | 12 | import "encoding/binary" 13 | 14 | // xorIn xors the bytes in buf into the state; it 15 | // makes no non-portable assumptions about memory layout 16 | // or alignment. 17 | func xorIn(d *State, buf []byte) { 18 | n := len(buf) / 8 19 | 20 | for i := 0; i < n; i++ { 21 | a := binary.LittleEndian.Uint64(buf) 22 | d.a[i] ^= a 23 | buf = buf[8:] 24 | } 25 | } 26 | 27 | // copyOut copies ulint64s to a byte buffer. 28 | func copyOut(d *State, b []byte) { 29 | for i := 0; len(b) >= 8; i++ { 30 | binary.LittleEndian.PutUint64(b, d.a[i]) 31 | b = b[8:] 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband/common.go: -------------------------------------------------------------------------------- 1 | package sideband 2 | 3 | // Type sideband type "side-band" or "side-band-64k" 4 | type Type int8 5 | 6 | const ( 7 | // Sideband legacy sideband type up to 1000-byte messages 8 | Sideband Type = iota 9 | // Sideband64k sideband type up to 65519-byte messages 10 | Sideband64k Type = iota 11 | 12 | // MaxPackedSize for Sideband type 13 | MaxPackedSize = 1000 14 | // MaxPackedSize64k for Sideband64k type 15 | MaxPackedSize64k = 65520 16 | ) 17 | 18 | // Channel sideband channel 19 | type Channel byte 20 | 21 | // WithPayload encode the payload as a message 22 | func (ch Channel) WithPayload(payload []byte) []byte { 23 | return append([]byte{byte(ch)}, payload...) 24 | } 25 | 26 | const ( 27 | // PackData packfile content 28 | PackData Channel = 1 29 | // ProgressMessage progress messages 30 | ProgressMessage Channel = 2 31 | // ErrorMessage fatal error message just before stream aborts 32 | ErrorMessage Channel = 3 33 | ) 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_aix_ppc64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix && ppc64 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used AIX. 9 | 10 | package unix 11 | 12 | // Major returns the major component of a Linux device number. 13 | func Major(dev uint64) uint32 { 14 | return uint32((dev & 0x3fffffff00000000) >> 32) 15 | } 16 | 17 | // Minor returns the minor component of a Linux device number. 18 | func Minor(dev uint64) uint32 { 19 | return uint32((dev & 0x00000000ffffffff) >> 0) 20 | } 21 | 22 | // Mkdev returns a Linux device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | var DEVNO64 uint64 26 | DEVNO64 = 0x8000000000000000 27 | return ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm64 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/colorable_appengine.go: -------------------------------------------------------------------------------- 1 | //go:build appengine 2 | // +build appengine 3 | 4 | package colorable 5 | 6 | import ( 7 | "io" 8 | "os" 9 | 10 | _ "github.com/mattn/go-isatty" 11 | ) 12 | 13 | // NewColorable returns new instance of Writer which handles escape sequence. 14 | func NewColorable(file *os.File) io.Writer { 15 | if file == nil { 16 | panic("nil passed instead of *os.File to NewColorable()") 17 | } 18 | 19 | return file 20 | } 21 | 22 | // NewColorableStdout returns new instance of Writer which handles escape sequence for stdout. 23 | func NewColorableStdout() io.Writer { 24 | return os.Stdout 25 | } 26 | 27 | // NewColorableStderr returns new instance of Writer which handles escape sequence for stderr. 28 | func NewColorableStderr() io.Writer { 29 | return os.Stderr 30 | } 31 | 32 | // EnableColorsStdout enable colors if possible. 33 | func EnableColorsStdout(enabled *bool) func() { 34 | if enabled != nil { 35 | *enabled = true 36 | } 37 | return func() {} 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: int32(nsec)} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint32(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint32(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: int32(nsec)} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint32(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint32(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Describe the bug** 11 | A clear and concise description of what the bug is. 12 | 13 | **To Reproduce** 14 | Steps to reproduce the behavior: 15 | 1. Go to '...' 16 | 2. Click on '....' 17 | 3. Scroll down to '....' 18 | 4. See error 19 | 20 | **Expected behavior** 21 | A clear and concise description of what you expected to happen. 22 | 23 | **Screenshots** 24 | If applicable, add screenshots to help explain your problem. 25 | 26 | **Desktop (please complete the following information):** 27 | - OS: [e.g. iOS] 28 | - Browser [e.g. chrome, safari] 29 | - Version [e.g. 22] 30 | 31 | **Smartphone (please complete the following information):** 32 | - Device: [e.g. iPhone6] 33 | - OS: [e.g. iOS8.1] 34 | - Browser [e.g. stock browser, safari] 35 | - Version [e.g. 22] 36 | 37 | **Additional context** 38 | Add any other context about the problem here. 39 | -------------------------------------------------------------------------------- /internal/core/repository/repository.go: -------------------------------------------------------------------------------- 1 | package repository 2 | 3 | import ( 4 | "time" 5 | 6 | "github.com/DiegoDev2/Fleet/pkg/manifest" 7 | ) 8 | 9 | // Repository define la interfaz que deben implementar todos los repositorios 10 | type Repository interface { 11 | // GetName devuelve el nombre del repositorio 12 | GetName() string 13 | 14 | // GetURL devuelve la URL del repositorio 15 | GetURL() string 16 | 17 | // GetType devuelve el tipo del repositorio 18 | GetType() string 19 | 20 | // GetPriority devuelve la prioridad del repositorio 21 | GetPriority() int 22 | 23 | // GetLastSync devuelve la fecha de la última sincronización 24 | GetLastSync() time.Time 25 | 26 | // Sync sincroniza el repositorio con la fuente remota 27 | Sync() error 28 | 29 | // GetManifest obtiene un manifiesto específico del repositorio 30 | GetManifest(toolName string) (*manifest.Manifest, error) 31 | 32 | // ListManifests devuelve todos los manifiestos disponibles en el repositorio 33 | ListManifests() ([]*manifest.Manifest, error) 34 | } 35 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/colorable_others.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !appengine 2 | // +build !windows,!appengine 3 | 4 | package colorable 5 | 6 | import ( 7 | "io" 8 | "os" 9 | 10 | _ "github.com/mattn/go-isatty" 11 | ) 12 | 13 | // NewColorable returns new instance of Writer which handles escape sequence. 14 | func NewColorable(file *os.File) io.Writer { 15 | if file == nil { 16 | panic("nil passed instead of *os.File to NewColorable()") 17 | } 18 | 19 | return file 20 | } 21 | 22 | // NewColorableStdout returns new instance of Writer which handles escape sequence for stdout. 23 | func NewColorableStdout() io.Writer { 24 | return os.Stdout 25 | } 26 | 27 | // NewColorableStderr returns new instance of Writer which handles escape sequence for stderr. 28 | func NewColorableStderr() io.Writer { 29 | return os.Stderr 30 | } 31 | 32 | // EnableColorsStdout enable colors if possible. 33 | func EnableColorsStdout(enabled *bool) func() { 34 | if enabled != nil { 35 | *enabled = true 36 | } 37 | return func() {} 38 | } 39 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/storage/storer.go: -------------------------------------------------------------------------------- 1 | package storage 2 | 3 | import ( 4 | "errors" 5 | 6 | "github.com/go-git/go-git/v5/config" 7 | "github.com/go-git/go-git/v5/plumbing/storer" 8 | ) 9 | 10 | var ErrReferenceHasChanged = errors.New("reference has changed concurrently") 11 | 12 | // Storer is a generic storage of objects, references and any information 13 | // related to a particular repository. The package github.com/go-git/go-git/v5/storage 14 | // contains two implementation a filesystem base implementation (such as `.git`) 15 | // and a memory implementations being ephemeral 16 | type Storer interface { 17 | storer.EncodedObjectStorer 18 | storer.ReferenceStorer 19 | storer.ShallowStorer 20 | storer.IndexStorer 21 | config.ConfigStorer 22 | ModuleStorer 23 | } 24 | 25 | // ModuleStorer allows interact with the modules' Storers 26 | type ModuleStorer interface { 27 | // Module returns a Storer representing a submodule, if not exists returns a 28 | // new empty Storer is returned 29 | Module(name string) (Storer, error) 30 | } 31 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing to Fleet 2 | 3 | Thank you for your interest in contributing to **Fleet**! We value your help in improving this project. Below are guidelines on how you can contribute effectively. 4 | 5 | ## Table of Contents 6 | 7 | 1. [Getting Started](#getting-started) 8 | 2. [Reporting Bugs](#reporting-bugs) 9 | 3. [Feature Requests](#feature-requests) 10 | 4. [Contributing Guidelines](#contributing-guidelines) 11 | 5. [Writing Tests](#writing-tests) 12 | 6. [Code Style](#code-style) 13 | 7. [Questions](#questions) 14 | 15 | ## Getting Started 16 | 17 | ### 1. Clone the Repository 18 | 19 | Clone the **Fleet** repository to your local machine: 20 | 21 | ```bash 22 | git clone https://github.com/DiegoDev2/Fleet.git 23 | cd Fleet 24 | ``` 25 | ### 2. Create a Branch 26 | 27 | Create a new branch for your contribution: 28 | 29 | ```bash 30 | git checkout -b your-branch-name 31 | ``` 32 | ### 3. Install Dependencies 33 | 34 | To install the necessary dependencies: 35 | 36 | ```bash 37 | go mod tidy 38 | ``` 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_netbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in NetBSD's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a NetBSD device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev & 0x000fff00) >> 8) 13 | } 14 | 15 | // Minor returns the minor component of a NetBSD device number. 16 | func Minor(dev uint64) uint32 { 17 | minor := uint32((dev & 0x000000ff) >> 0) 18 | minor |= uint32((dev & 0xfff00000) >> 12) 19 | return minor 20 | } 21 | 22 | // Mkdev returns a NetBSD device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | dev := (uint64(major) << 8) & 0x000fff00 26 | dev |= (uint64(minor) << 12) & 0xfff00000 27 | dev |= (uint64(minor) << 0) & 0x000000ff 28 | return dev 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/errors.go: -------------------------------------------------------------------------------- 1 | package gcfg 2 | 3 | import ( 4 | "gopkg.in/warnings.v0" 5 | ) 6 | 7 | // FatalOnly filters the results of a Read*Into invocation and returns only 8 | // fatal errors. That is, errors (warnings) indicating data for unknown 9 | // sections / variables is ignored. Example invocation: 10 | // 11 | // err := gcfg.FatalOnly(gcfg.ReadFileInto(&cfg, configFile)) 12 | // if err != nil { 13 | // ... 14 | // 15 | func FatalOnly(err error) error { 16 | return warnings.FatalOnly(err) 17 | } 18 | 19 | func isFatal(err error) bool { 20 | _, ok := err.(extraData) 21 | return !ok 22 | } 23 | 24 | type extraData struct { 25 | section string 26 | subsection *string 27 | variable *string 28 | } 29 | 30 | func (e extraData) Error() string { 31 | s := "can't store data at section \"" + e.section + "\"" 32 | if e.subsection != nil { 33 | s += ", subsection \"" + *e.subsection + "\"" 34 | } 35 | if e.variable != nil { 36 | s += ", variable \"" + *e.variable + "\"" 37 | } 38 | return s 39 | } 40 | 41 | var _ error = extraData{} 42 | -------------------------------------------------------------------------------- /vendor/github.com/sergi/go-diff/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of go-diff authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | # Please keep the list sorted. 10 | 11 | Danny Yoo 12 | James Kolb 13 | Jonathan Amsterdam 14 | Markus Zimmermann 15 | Matt Kovars 16 | Örjan Persson 17 | Osman Masood 18 | Robert Carlsen 19 | Rory Flynn 20 | Sergi Mansilla 21 | Shatrugna Sadhu 22 | Shawn Smith 23 | Stas Maksimov 24 | Tor Arvid Lund 25 | Zac Bergquist 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_openbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in OpenBSD's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of an OpenBSD device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev & 0x0000ff00) >> 8) 13 | } 14 | 15 | // Minor returns the minor component of an OpenBSD device number. 16 | func Minor(dev uint64) uint32 { 17 | minor := uint32((dev & 0x000000ff) >> 0) 18 | minor |= uint32((dev & 0xffff0000) >> 8) 19 | return minor 20 | } 21 | 22 | // Mkdev returns an OpenBSD device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | dev := (uint64(major) << 8) & 0x0000ff00 26 | dev |= (uint64(minor) << 8) & 0xffff0000 27 | dev |= (uint64(minor) << 0) & 0x000000ff 28 | return dev 29 | } 30 | -------------------------------------------------------------------------------- /internal/core/manifest/types.go: -------------------------------------------------------------------------------- 1 | package manifest 2 | 3 | import ( 4 | "github.com/DiegoDev2/Fleet/pkg/manifest" 5 | ) 6 | 7 | type ManifestSource struct { 8 | Type string 9 | Location string 10 | RepoName string 11 | } 12 | 13 | type ManifestWithMetadata struct { 14 | Manifest *manifest.Manifest 15 | Source ManifestSource 16 | Cached bool 17 | Modified string 18 | } 19 | 20 | type ValidationContext struct { 21 | StrictMode bool 22 | Platform string 23 | Arch string 24 | } 25 | 26 | type ManifestIndex struct { 27 | ByName map[string]*manifest.Manifest 28 | ByCategory map[string][]*manifest.Manifest 29 | } 30 | 31 | func NewManifestIndex() *ManifestIndex { 32 | return &ManifestIndex{ 33 | ByName: make(map[string]*manifest.Manifest), 34 | ByCategory: make(map[string][]*manifest.Manifest), 35 | } 36 | } 37 | 38 | func (idx *ManifestIndex) AddToIndex(m *manifest.Manifest) { 39 | idx.ByName[m.Name] = m 40 | 41 | for _, category := range m.Categories { 42 | idx.ByCategory[category] = append(idx.ByCategory[category], m) 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/transport/http/transport.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "net/http" 5 | "net/url" 6 | ) 7 | 8 | // transportOptions contains transport specific configuration. 9 | type transportOptions struct { 10 | insecureSkipTLS bool 11 | // []byte is not comparable. 12 | clientCert string 13 | clientKey string 14 | caBundle string 15 | proxyURL url.URL 16 | } 17 | 18 | func (c *client) addTransport(opts transportOptions, transport *http.Transport) { 19 | c.mutex.Lock() 20 | c.transports.Add(opts, transport) 21 | c.mutex.Unlock() 22 | } 23 | 24 | func (c *client) removeTransport(opts transportOptions) { 25 | c.mutex.Lock() 26 | c.transports.Remove(opts) 27 | c.mutex.Unlock() 28 | } 29 | 30 | func (c *client) fetchTransport(opts transportOptions) (*http.Transport, bool) { 31 | c.mutex.RLock() 32 | t, ok := c.transports.Get(opts) 33 | c.mutex.RUnlock() 34 | if !ok { 35 | return nil, false 36 | } 37 | transport, ok := t.(*http.Transport) 38 | if !ok { 39 | return nil, false 40 | } 41 | return transport, true 42 | } 43 | -------------------------------------------------------------------------------- /vendor/github.com/cyphar/filepath-securejoin/gocompat_errors_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build linux && !go1.20 2 | 3 | // Copyright (C) 2024 SUSE LLC. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | package securejoin 8 | 9 | import ( 10 | "fmt" 11 | ) 12 | 13 | type wrappedError struct { 14 | inner error 15 | isError error 16 | } 17 | 18 | func (err wrappedError) Is(target error) bool { 19 | return err.isError == target 20 | } 21 | 22 | func (err wrappedError) Unwrap() error { 23 | return err.inner 24 | } 25 | 26 | func (err wrappedError) Error() string { 27 | return fmt.Sprintf("%v: %v", err.isError, err.inner) 28 | } 29 | 30 | // wrapBaseError is a helper that is equivalent to fmt.Errorf("%w: %w"), except 31 | // that on pre-1.20 Go versions only errors.Is() works properly (errors.Unwrap) 32 | // is only guaranteed to give you baseErr. 33 | func wrapBaseError(baseErr, extraErr error) error { 34 | return wrappedError{ 35 | inner: baseErr, 36 | isError: extraErr, 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/storage/filesystem/config.go: -------------------------------------------------------------------------------- 1 | package filesystem 2 | 3 | import ( 4 | "os" 5 | 6 | "github.com/go-git/go-git/v5/config" 7 | "github.com/go-git/go-git/v5/storage/filesystem/dotgit" 8 | "github.com/go-git/go-git/v5/utils/ioutil" 9 | ) 10 | 11 | type ConfigStorage struct { 12 | dir *dotgit.DotGit 13 | } 14 | 15 | func (c *ConfigStorage) Config() (conf *config.Config, err error) { 16 | f, err := c.dir.Config() 17 | if err != nil { 18 | if os.IsNotExist(err) { 19 | return config.NewConfig(), nil 20 | } 21 | 22 | return nil, err 23 | } 24 | 25 | defer ioutil.CheckClose(f, &err) 26 | return config.ReadConfig(f) 27 | } 28 | 29 | func (c *ConfigStorage) SetConfig(cfg *config.Config) (err error) { 30 | if err = cfg.Validate(); err != nil { 31 | return err 32 | } 33 | 34 | f, err := c.dir.ConfigWriter() 35 | if err != nil { 36 | return err 37 | } 38 | 39 | defer ioutil.CheckClose(f, &err) 40 | 41 | b, err := cfg.Marshal() 42 | if err != nil { 43 | return err 44 | } 45 | 46 | _, err = f.Write(b) 47 | return err 48 | } 49 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/Makefile: -------------------------------------------------------------------------------- 1 | BIN="./bin" 2 | SRC=$(shell find . -name "*.go") 3 | 4 | ifeq (, $(shell which golangci-lint)) 5 | $(warning "could not find golangci-lint in $(PATH), run: curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh") 6 | endif 7 | 8 | .PHONY: fmt lint test install_deps clean 9 | 10 | default: all 11 | 12 | all: fmt test 13 | 14 | fmt: 15 | $(info ******************** checking formatting ********************) 16 | @test -z $(shell gofmt -l $(SRC)) || (gofmt -d $(SRC); exit 1) 17 | 18 | lint: 19 | $(info ******************** running lint tools ********************) 20 | golangci-lint run -v 21 | 22 | test: install_deps 23 | $(info ******************** running tests ********************) 24 | go test -v ./... 25 | 26 | richtest: install_deps 27 | $(info ******************** running tests with kyoh86/richgo ********************) 28 | richgo test -v ./... 29 | 30 | install_deps: 31 | $(info ******************** downloading dependencies ********************) 32 | go get -v ./... 33 | 34 | clean: 35 | rm -rf $(BIN) 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/ssh/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | /* 6 | Package ssh implements an SSH client and server. 7 | 8 | SSH is a transport security protocol, an authentication protocol and a 9 | family of application protocols. The most typical application level 10 | protocol is a remote shell and this is specifically implemented. However, 11 | the multiplexed nature of SSH is exposed to users that wish to support 12 | others. 13 | 14 | References: 15 | 16 | [PROTOCOL]: https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL?rev=HEAD 17 | [PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD 18 | [SSH-PARAMETERS]: http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1 19 | 20 | This package does not fall under the stability promise of the Go language itself, 21 | so its API may be changed when pressing needs arise. 22 | */ 23 | package ssh 24 | -------------------------------------------------------------------------------- /vendor/github.com/emirpasic/gods/trees/binaryheap/serialization.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2015, Emir Pasic. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package binaryheap 6 | 7 | import ( 8 | "github.com/emirpasic/gods/containers" 9 | ) 10 | 11 | // Assert Serialization implementation 12 | var _ containers.JSONSerializer = (*Heap)(nil) 13 | var _ containers.JSONDeserializer = (*Heap)(nil) 14 | 15 | // ToJSON outputs the JSON representation of the heap. 16 | func (heap *Heap) ToJSON() ([]byte, error) { 17 | return heap.list.ToJSON() 18 | } 19 | 20 | // FromJSON populates the heap from the input JSON representation. 21 | func (heap *Heap) FromJSON(data []byte) error { 22 | return heap.list.FromJSON(data) 23 | } 24 | 25 | // UnmarshalJSON @implements json.Unmarshaler 26 | func (heap *Heap) UnmarshalJSON(bytes []byte) error { 27 | return heap.FromJSON(bytes) 28 | } 29 | 30 | // MarshalJSON @implements json.Marshaler 31 | func (heap *Heap) MarshalJSON() ([]byte, error) { 32 | return heap.ToJSON() 33 | } 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | const ( 8 | // bit mask values from /usr/include/bits/hwcap.h 9 | hwcap_ZARCH = 2 10 | hwcap_STFLE = 4 11 | hwcap_MSA = 8 12 | hwcap_LDISP = 16 13 | hwcap_EIMM = 32 14 | hwcap_DFP = 64 15 | hwcap_ETF3EH = 256 16 | hwcap_VX = 2048 17 | hwcap_VXE = 8192 18 | ) 19 | 20 | func initS390Xbase() { 21 | // test HWCAP bit vector 22 | has := func(featureMask uint) bool { 23 | return hwCap&featureMask == featureMask 24 | } 25 | 26 | // mandatory 27 | S390X.HasZARCH = has(hwcap_ZARCH) 28 | 29 | // optional 30 | S390X.HasSTFLE = has(hwcap_STFLE) 31 | S390X.HasLDISP = has(hwcap_LDISP) 32 | S390X.HasEIMM = has(hwcap_EIMM) 33 | S390X.HasETF3EH = has(hwcap_ETF3EH) 34 | S390X.HasDFP = has(hwcap_DFP) 35 | S390X.HasMSA = has(hwcap_MSA) 36 | S390X.HasVX = has(hwcap_VX) 37 | if S390X.HasVX { 38 | S390X.HasVXE = has(hwcap_VXE) 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /tests/unit/repository_test.go: -------------------------------------------------------------------------------- 1 | package unit 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/DiegoDev2/Fleet/internal/core/repository" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestRepositoryManager(t *testing.T) { 11 | 12 | tempDir := t.TempDir() 13 | 14 | manager, err := repository.NewManager(tempDir) 15 | assert.NoError(t, err) 16 | assert.NotNil(t, manager) 17 | 18 | err = manager.AddRepository("test-repo", "https://example.com/repo", "http", 100) 19 | assert.NoError(t, err) 20 | 21 | repos := manager.ListRepositories() 22 | assert.Len(t, repos, 1) 23 | 24 | //repoList, ok := repos.([]repository.Repository) 25 | //assert.True(t, ok, "expected repos to be of type []repository.Repository") 26 | // assert.Equal(t, "test-repo", repoList[0].Name) 27 | // assert.Equal(t, "https://example.com/repo", repos[0].URL) 28 | // assert.Equal(t, "http", repos[0].Type) 29 | // assert.Equal(t, 100, repos[0].Priority) 30 | 31 | err = manager.RemoveRepository("test-repo") 32 | assert.NoError(t, err) 33 | 34 | repos = manager.ListRepositories() 35 | assert.Empty(t, repos) 36 | } 37 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/token.go: -------------------------------------------------------------------------------- 1 | package ssh_config 2 | 3 | import "fmt" 4 | 5 | type token struct { 6 | Position 7 | typ tokenType 8 | val string 9 | } 10 | 11 | func (t token) String() string { 12 | switch t.typ { 13 | case tokenEOF: 14 | return "EOF" 15 | } 16 | return fmt.Sprintf("%q", t.val) 17 | } 18 | 19 | type tokenType int 20 | 21 | const ( 22 | eof = -(iota + 1) 23 | ) 24 | 25 | const ( 26 | tokenError tokenType = iota 27 | tokenEOF 28 | tokenEmptyLine 29 | tokenComment 30 | tokenKey 31 | tokenEquals 32 | tokenString 33 | ) 34 | 35 | func isSpace(r rune) bool { 36 | return r == ' ' || r == '\t' 37 | } 38 | 39 | func isKeyStartChar(r rune) bool { 40 | return !(isSpace(r) || r == '\r' || r == '\n' || r == eof) 41 | } 42 | 43 | // I'm not sure that this is correct 44 | func isKeyChar(r rune) bool { 45 | // Keys start with the first character that isn't whitespace or [ and end 46 | // with the last non-whitespace character before the equals sign. Keys 47 | // cannot contain a # character." 48 | return !(r == '\r' || r == '\n' || r == eof || r == '=') 49 | } 50 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && gc && !purego 6 | 7 | package blake2b 8 | 9 | import "golang.org/x/sys/cpu" 10 | 11 | func init() { 12 | useAVX2 = cpu.X86.HasAVX2 13 | useAVX = cpu.X86.HasAVX 14 | useSSE4 = cpu.X86.HasSSE41 15 | } 16 | 17 | //go:noescape 18 | func hashBlocksAVX2(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) 19 | 20 | //go:noescape 21 | func hashBlocksAVX(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) 22 | 23 | //go:noescape 24 | func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) 25 | 26 | func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) { 27 | switch { 28 | case useAVX2: 29 | hashBlocksAVX2(h, c, flag, blocks) 30 | case useAVX: 31 | hashBlocksAVX(h, c, flag, blocks) 32 | case useSSE4: 33 | hashBlocksSSE4(h, c, flag, blocks) 34 | default: 35 | hashBlocksGeneric(h, c, flag, blocks) 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/format/gitignore/matcher.go: -------------------------------------------------------------------------------- 1 | package gitignore 2 | 3 | // Matcher defines a global multi-pattern matcher for gitignore patterns 4 | type Matcher interface { 5 | // Match matches patterns in the order of priorities. As soon as an inclusion or 6 | // exclusion is found, not further matching is performed. 7 | Match(path []string, isDir bool) bool 8 | } 9 | 10 | // NewMatcher constructs a new global matcher. Patterns must be given in the order of 11 | // increasing priority. That is most generic settings files first, then the content of 12 | // the repo .gitignore, then content of .gitignore down the path or the repo and then 13 | // the content command line arguments. 14 | func NewMatcher(ps []Pattern) Matcher { 15 | return &matcher{ps} 16 | } 17 | 18 | type matcher struct { 19 | patterns []Pattern 20 | } 21 | 22 | func (m *matcher) Match(path []string, isDir bool) bool { 23 | n := len(m.patterns) 24 | for i := n - 1; i >= 0; i-- { 25 | if match := m.patterns[i].Match(path, isDir); match > NoMatch { 26 | return match == Exclude 27 | } 28 | } 29 | return false 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/math/fp448/fp_amd64.go: -------------------------------------------------------------------------------- 1 | //go:build amd64 && !purego 2 | // +build amd64,!purego 3 | 4 | package fp448 5 | 6 | import ( 7 | "golang.org/x/sys/cpu" 8 | ) 9 | 10 | var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX 11 | 12 | var _ = hasBmi2Adx 13 | 14 | func cmov(x, y *Elt, n uint) { cmovAmd64(x, y, n) } 15 | func cswap(x, y *Elt, n uint) { cswapAmd64(x, y, n) } 16 | func add(z, x, y *Elt) { addAmd64(z, x, y) } 17 | func sub(z, x, y *Elt) { subAmd64(z, x, y) } 18 | func addsub(x, y *Elt) { addsubAmd64(x, y) } 19 | func mul(z, x, y *Elt) { mulAmd64(z, x, y) } 20 | func sqr(z, x *Elt) { sqrAmd64(z, x) } 21 | 22 | /* Functions defined in fp_amd64.s */ 23 | 24 | //go:noescape 25 | func cmovAmd64(x, y *Elt, n uint) 26 | 27 | //go:noescape 28 | func cswapAmd64(x, y *Elt, n uint) 29 | 30 | //go:noescape 31 | func addAmd64(z, x, y *Elt) 32 | 33 | //go:noescape 34 | func subAmd64(z, x, y *Elt) 35 | 36 | //go:noescape 37 | func addsubAmd64(x, y *Elt) 38 | 39 | //go:noescape 40 | func mulAmd64(z, x, y *Elt) 41 | 42 | //go:noescape 43 | func sqrAmd64(z, x *Elt) 44 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64 || ppc64le) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, Linux 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 17 | BL runtime·entersyscall(SB) 18 | MOVD a1+8(FP), R3 19 | MOVD a2+16(FP), R4 20 | MOVD a3+24(FP), R5 21 | MOVD R0, R6 22 | MOVD R0, R7 23 | MOVD R0, R8 24 | MOVD trap+0(FP), R9 // syscall entry 25 | SYSCALL R9 26 | MOVD R3, r1+32(FP) 27 | MOVD R4, r2+40(FP) 28 | BL runtime·exitsyscall(SB) 29 | RET 30 | 31 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 32 | MOVD a1+8(FP), R3 33 | MOVD a2+16(FP), R4 34 | MOVD a3+24(FP), R5 35 | MOVD R0, R6 36 | MOVD R0, R7 37 | MOVD R0, R8 38 | MOVD trap+0(FP), R9 // syscall entry 39 | SYSCALL R9 40 | MOVD R3, r1+32(FP) 41 | MOVD R4, r2+40(FP) 42 | RET 43 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/sha3_s390x.s: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego 6 | 7 | #include "textflag.h" 8 | 9 | // func kimd(function code, chain *[200]byte, src []byte) 10 | TEXT ·kimd(SB), NOFRAME|NOSPLIT, $0-40 11 | MOVD function+0(FP), R0 12 | MOVD chain+8(FP), R1 13 | LMG src+16(FP), R2, R3 // R2=base, R3=len 14 | 15 | continue: 16 | WORD $0xB93E0002 // KIMD --, R2 17 | BVS continue // continue if interrupted 18 | MOVD $0, R0 // reset R0 for pre-go1.8 compilers 19 | RET 20 | 21 | // func klmd(function code, chain *[200]byte, dst, src []byte) 22 | TEXT ·klmd(SB), NOFRAME|NOSPLIT, $0-64 23 | // TODO: SHAKE support 24 | MOVD function+0(FP), R0 25 | MOVD chain+8(FP), R1 26 | LMG dst+16(FP), R2, R3 // R2=base, R3=len 27 | LMG src+40(FP), R4, R5 // R4=base, R5=len 28 | 29 | continue: 30 | WORD $0xB93F0024 // KLMD R2, R4 31 | BVS continue // continue if interrupted 32 | MOVD $0, R0 // reset R0 for pre-go1.8 compilers 33 | RET 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // func getisar0() uint64 10 | TEXT ·getisar0(SB),NOSPLIT,$0-8 11 | // get Instruction Set Attributes 0 into x0 12 | // mrs x0, ID_AA64ISAR0_EL1 = d5380600 13 | WORD $0xd5380600 14 | MOVD R0, ret+0(FP) 15 | RET 16 | 17 | // func getisar1() uint64 18 | TEXT ·getisar1(SB),NOSPLIT,$0-8 19 | // get Instruction Set Attributes 1 into x0 20 | // mrs x0, ID_AA64ISAR1_EL1 = d5380620 21 | WORD $0xd5380620 22 | MOVD R0, ret+0(FP) 23 | RET 24 | 25 | // func getpfr0() uint64 26 | TEXT ·getpfr0(SB),NOSPLIT,$0-8 27 | // get Processor Feature Register 0 into x0 28 | // mrs x0, ID_AA64PFR0_EL1 = d5380400 29 | WORD $0xd5380400 30 | MOVD R0, ret+0(FP) 31 | RET 32 | 33 | // func getzfr0() uint64 34 | TEXT ·getzfr0(SB),NOSPLIT,$0-8 35 | // get SVE Feature Register 0 into x0 36 | // mrs x0, ID_AA64ZFR0_EL1 = d5380480 37 | WORD $0xd5380480 38 | MOVD R0, ret+0(FP) 39 | RET 40 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/ocb/rfc7253_test_vectors_suite_b.go: -------------------------------------------------------------------------------- 1 | package ocb 2 | 3 | // Second set of test vectors from https://tools.ietf.org/html/rfc7253 4 | var rfc7253TestVectorTaglen96 = struct { 5 | key, nonce, header, plaintext, ciphertext string 6 | }{"0F0E0D0C0B0A09080706050403020100", 7 | "BBAA9988776655443322110D", 8 | "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627", 9 | "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627", 10 | "1792A4E31E0755FB03E31B22116E6C2DDF9EFD6E33D536F1A0124B0A55BAE884ED93481529C76B6AD0C515F4D1CDD4FDAC4F02AA"} 11 | 12 | var rfc7253AlgorithmTest = []struct { 13 | KEYLEN, TAGLEN int 14 | OUTPUT string 15 | }{ 16 | {128, 128, "67E944D23256C5E0B6C61FA22FDF1EA2"}, 17 | {192, 128, "F673F2C3E7174AAE7BAE986CA9F29E17"}, 18 | {256, 128, "D90EB8E9C977C88B79DD793D7FFA161C"}, 19 | {128, 96, "77A3D8E73589158D25D01209"}, 20 | {192, 96, "05D56EAD2752C86BE6932C5E"}, 21 | {256, 96, "5458359AC23B0CBA9E6330DD"}, 22 | {128, 64, "192C9B7BD90BA06A"}, 23 | {192, 64, "0066BC6E0EF34E24"}, 24 | {256, 64, "7D4EA5D445501CBE"}, 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/math/primes.go: -------------------------------------------------------------------------------- 1 | package math 2 | 3 | import ( 4 | "crypto/rand" 5 | "io" 6 | "math/big" 7 | ) 8 | 9 | // IsSafePrime reports whether p is (probably) a safe prime. 10 | // The prime p=2*q+1 is safe prime if both p and q are primes. 11 | // Note that ProbablyPrime is not suitable for judging primes 12 | // that an adversary may have crafted to fool the test. 13 | func IsSafePrime(p *big.Int) bool { 14 | pdiv2 := new(big.Int).Rsh(p, 1) 15 | return p.ProbablyPrime(20) && pdiv2.ProbablyPrime(20) 16 | } 17 | 18 | // SafePrime returns a number of the given bit length that is a safe prime with high probability. 19 | // The number returned p=2*q+1 is a safe prime if both p and q are primes. 20 | // SafePrime will return error for any error returned by rand.Read or if bits < 2. 21 | func SafePrime(random io.Reader, bits int) (*big.Int, error) { 22 | one := big.NewInt(1) 23 | p := new(big.Int) 24 | for { 25 | q, err := rand.Prime(random, bits-1) 26 | if err != nil { 27 | return nil, err 28 | } 29 | p.Lsh(q, 1).Add(p, one) 30 | if p.ProbablyPrime(20) { 31 | return p, nil 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/transport/internal/common/mocks.go: -------------------------------------------------------------------------------- 1 | package common 2 | 3 | import ( 4 | "bytes" 5 | "io" 6 | 7 | gogitioutil "github.com/go-git/go-git/v5/utils/ioutil" 8 | 9 | "github.com/go-git/go-git/v5/plumbing/transport" 10 | ) 11 | 12 | type MockCommand struct { 13 | stdin bytes.Buffer 14 | stdout bytes.Buffer 15 | stderr bytes.Buffer 16 | } 17 | 18 | func (c MockCommand) StderrPipe() (io.Reader, error) { 19 | return &c.stderr, nil 20 | } 21 | 22 | func (c MockCommand) StdinPipe() (io.WriteCloser, error) { 23 | return gogitioutil.WriteNopCloser(&c.stdin), nil 24 | } 25 | 26 | func (c MockCommand) StdoutPipe() (io.Reader, error) { 27 | return &c.stdout, nil 28 | } 29 | 30 | func (c MockCommand) Start() error { 31 | return nil 32 | } 33 | 34 | func (c MockCommand) Close() error { 35 | panic("not implemented") 36 | } 37 | 38 | type MockCommander struct { 39 | stderr string 40 | } 41 | 42 | func (c MockCommander) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (Command, error) { 43 | return &MockCommand{ 44 | stderr: *bytes.NewBufferString(c.stderr), 45 | }, nil 46 | } 47 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/internal/sha3/sha3_s390x.s: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo,!appengine 6 | 7 | #include "textflag.h" 8 | 9 | // func kimd(function code, chain *[200]byte, src []byte) 10 | TEXT ·kimd(SB), NOFRAME|NOSPLIT, $0-40 11 | MOVD function+0(FP), R0 12 | MOVD chain+8(FP), R1 13 | LMG src+16(FP), R2, R3 // R2=base, R3=len 14 | 15 | continue: 16 | WORD $0xB93E0002 // KIMD --, R2 17 | BVS continue // continue if interrupted 18 | MOVD $0, R0 // reset R0 for pre-go1.8 compilers 19 | RET 20 | 21 | // func klmd(function code, chain *[200]byte, dst, src []byte) 22 | TEXT ·klmd(SB), NOFRAME|NOSPLIT, $0-64 23 | // TODO: SHAKE support 24 | MOVD function+0(FP), R0 25 | MOVD chain+8(FP), R1 26 | LMG dst+16(FP), R2, R3 // R2=base, R3=len 27 | LMG src+40(FP), R4, R5 // R4=base, R5=len 28 | 29 | continue: 30 | WORD $0xB93F0024 // KLMD R2, R4 31 | BVS continue // continue if interrupted 32 | MOVD $0, R0 // reset R0 for pre-go1.8 compilers 33 | RET 34 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) Yasuhiro MATSUMOTO 2 | 3 | MIT License (Expat) 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 6 | 7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gccgo 6 | 7 | package cpu 8 | 9 | // haveAsmFunctions reports whether the other functions in this file can 10 | // be safely called. 11 | func haveAsmFunctions() bool { return false } 12 | 13 | // TODO(mundaym): the following feature detection functions are currently 14 | // stubs. See https://golang.org/cl/162887 for how to fix this. 15 | // They are likely to be expensive to call so the results should be cached. 16 | func stfle() facilityList { panic("not implemented for gccgo") } 17 | func kmQuery() queryResult { panic("not implemented for gccgo") } 18 | func kmcQuery() queryResult { panic("not implemented for gccgo") } 19 | func kmctrQuery() queryResult { panic("not implemented for gccgo") } 20 | func kmaQuery() queryResult { panic("not implemented for gccgo") } 21 | func kimdQuery() queryResult { panic("not implemented for gccgo") } 22 | func klmdQuery() queryResult { panic("not implemented for gccgo") } 23 | --------------------------------------------------------------------------------