Skip to content

tt binary

Manage tt and tt Enterprise, Tarantool Community and Enterprise, TCM, and SDK bundles.

Use --scope to choose where binaries are managed:

project (default): .tarantool/ in the project directory: the current
  directory or its nearest parent with app.manifest.toml,
  .templates/<name>/instances.yaml or .templates/<name>/config.yaml; the
  current directory outside a project.
user: $TT_USER_ROOT when set; otherwise
  Linux: $XDG_DATA_HOME/tarantool when XDG_DATA_HOME is an absolute path;
    otherwise ~/.local/share/tarantool.
  macOS: ~/Library/Application Support/tarantool.
system: $TT_SYSTEM_ROOT when set; otherwise
  Linux: /opt/tarantool.
  macOS: /Library/Application Support/tarantool.

TT_USER_ROOT and TT_SYSTEM_ROOT must be absolute paths.

Each scope stores executables directly in <root>/versions/<product>/<product>_<version>/, with Tarantool headers in include/tarantool. Active executables are linked from <root>/bin/, and active Tarantool headers from <root>/include/tarantool.

Tarantool CE and EE keep separate versions and share the active Tarantool links. tt and tt-ee keep separate versions and share the active tt executable.

For project installations, run "source .env/activate.sh" in the project directory to activate the installed binaries.

SDK installations select Tarantool Enterprise, tt Enterprise, TCM, and headers together.

Usage

tt binary
tt binary [flags] <command> [command flags]

Commands

Flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary build

Build a program from its sources.

tt binary build tt builds a distribution of tt: a tt binary made of the tt core and the compiled-in tt modules tt.manifest.toml lists.

Usage

tt binary build
tt binary build [flags] <command> [command flags]

Commands

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary build tt

Build a distribution of tt from tt.manifest.toml: the tt core and the tt modules - Go modules that export a constructor of tt commands - compiled into one binary. The Go toolchain must be in PATH.

The smallest manifest builds tt itself on the core of the tt that runs the build; every other field is optional:

manifest_version = "0.1"
manifest_kind = "tt-distribution"

[package]
name = "tt"                   # the binary

[core]
tt = "v3.0.0-alpha.3"         # a version, a commit, latest: a Go query
# path = "../tt"              # or a local checkout of the core

[distribution]
title = "Tarantool CLI EE"    # how the binary presents itself
edition = "ee"
integrity = "rsa"             # none (default) or rsa
standard = true               # the standard modules of the core
exclude = ["emmylua"]         # but these
builtin = true                # tt's own commands
external_modules = true       # TT_CLI_MODULES_PATH

[build]
ssl = "default"               # default, openssl or openssl_static
tags = []
ldflags = []

[dependencies]
foo = "github.com/acme/tt-foo@v1.2.0"            # a module and a version
migrations = "./plugins/migrations"              # a local module

[replace]                     # Go modules the build takes from elsewhere
# a local directory
"example.com/lib" = "./libs/lib"
# a module version, or a query
"github.com/acme/lib/v2" = "github.com/acme/lib/v2@main"

[core].tt is a Go version query for the core module. Pin a version or a commit: Go reads "v3" as the newest v3.x.y release, never as the branch v3, and it matches no pre-release.

standard takes the standard modules of the core, the ones the official tt is built with, at the commit of the core; exclude leaves some of them out, and "builtin" in it is builtin = false. A module of [dependencies] named as a standard one takes its place; the build warns of it unless exclude names it too. A core with no package standard, before v3.0.0-alpha.3, needs standard = false.

A module of the core's repository is built at the commit of the core; any other module without a version at its latest. A module's constructor is New in its root package unless package and symbol say otherwise. Every module is built on the SDK of the core, whatever its go.mod requires.

[replace] does what replace directives of the generated go.mod do, which a tt module cannot do itself: Go applies the replace directives of the main module only, so a module that needs an unpublished library, or another version of one, cannot carry the replacement in its own go.mod. A key is a Go module path, optionally with @version to replace that version only; a value is a directory (it starts with ./, ../ or /; relative to the manifest, and it must hold that module) or <module>@<version>, where the version may be a query - a branch, a commit - that the build resolves to an exact version and the lock pins. The core, the modules of its repository and the tt modules of [dependencies] are not replaced here: use [core].path or --core for the core, and path or version of the dependency for a tt module.

The build writes tt.manifest.lock and tt.manifest.sum next to the manifest: the exact versions and the go.sum it was built from, and a hash of the files of every local module, local core and replaced directory. The hash leaves out go.work and go.work.sum, which the build does not read (see tt binary workspace), and what the .gitignore files of the module and of its repository ignore - read without git, and without the excludes of the machine - but the Go sources and the embedded files, which the build needs. While the manifest does not change, the next build takes the versions from the lock; --update resolves them again. --locked builds strictly from the lock and fails when it, the Go modules or the files of a local module or a replaced directory differ. The lock does not record how the binary is compiled - the TLS implementation, the tags, the toolchain - and is not rewritten when it would pin the same.

--vendor DIR makes an offline bundle instead of the binary: the generated main module with every module it is built from in vendor/, the local modules and the replaced directories copied into local/, the build parameters of each TLS implementation in build.env and build.sh, which builds the binary with nothing but the Go toolchain: no network, no module cache, no tt. The bundle names no directory of the machine that made it and is built once offline to check it.

--core VALUE, or TT_DIST_CORE, builds on another core than [core] says, without editing the manifest: a local checkout (an existing directory or a path that starts with ./, ../ or /) or a version query. Such a build is a development one: its core is not taken from the lock, the lock is not written, and --locked refuses it. The modules still come from the lock.

TT_CLI_BUILD_SSL, when set, overrides [build].ssl. VERSION_LABEL follows the version of the distribution, which is taken from git describe in the manifest's directory. The path to the binary, or to the bundle, is printed to stdout.

Usage

tt binary build tt [flags]

Flags

  • --core string - build on this core instead of [core]: a local checkout or a version query (env TT_DIST_CORE); the lock is left as it is
  • -C, --directory string - work on the project in DIR itself, not on the one the current directory is in
  • --locked - build strictly from tt.manifest.lock and write nothing but the binary
  • --manifest string - path to the manifest (default: tt.manifest.toml in the project directory)
  • -o, --output string - path to the binary (default: the package name in the manifest's directory)
  • --update - resolve the core and the modules again, ignoring the lock
  • --vendor string - make a bundle in DIR that go build turns into the binary offline, instead of the binary
  • --work string - generate the main module in DIR and keep it there

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

Examples

# Build the distribution in the current directory into ./<package.name>.
$ tt binary build tt

# Take the newest core and modules the manifest allows.
$ tt binary build tt --update

# Build exactly what the lock says, as CI does.
$ tt binary build tt --locked -o dist/tt

# Try the distribution on the core of a local checkout.
$ tt binary build tt --core ../tt

# Make an offline bundle, then build it where there is no network.
$ tt binary build tt --locked --vendor dist/bundle
$ sh dist/bundle/build.sh default ./tt

tt binary install

Install tt, Tarantool, Enterprise, and TCM.

The installed version becomes active in the selected scope. See "tt binary --help" for scope locations and the binary layout.

Project installations create .env/activate.sh and .env/deactivate.sh, and activate.fish and deactivate.fish for fish, in the project directory once. Source them to use the project binaries and headers or restore your shell environment. Outside a project, the project scope is the current directory: the first installation there says that it creates .tarantool/ and .env/ in it.

A build from source checks its dependencies first and names the packages that are missing; --force skips the check. On an OS whose packages tt does not know, tt asks whether to build without the check, and over an installed master it asks whether to look for newer commits. It asks on a terminal only, and --yes answers yes. Off a terminal or under --no-prompt, without --yes, the build on an unknown OS fails and the installed master is kept.

Usage

tt binary install [flags]
tt binary install [flags] <command> [command flags]

Commands

Flags

  • -f, --force - Skip dependency checks, and the question of an unknown OS
  • --no-clean - Keep temporary files
  • --reinstall - Reinstall an existing version
  • -y, --yes - Answer yes to the questions of the installation

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

Examples

# Install the latest Tarantool release for this project.
$ tt binary install tarantool

# Install tt for the current user.
$ tt binary install tt --scope user

# Install a local Enterprise archive system-wide.
$ sudo tt binary install tarantool gc64-3.4.0-0-r60 \
    --scope system --local-dir ./bundles

tt binary install tarantool

Install Tarantool Community or Enterprise Edition and its headers.

Bare versions select Community Edition: 3, 3.8, or 3.8.0. Tarantool Community Edition installation supports version 3.0 and newer.

On Linux amd64/arm64 with glibc, use prebuilt Community release binaries when available. Other platforms and releases without prebuilt packages are built from source automatically. Use --source-build to always compile Community releases from source.

EE suffix selects Enterprise Edition: 3.8.1ee or 3ee.

Enterprise archive names such as gc64-3.8.0-0-r94 also select Enterprise Edition. Use --dev for Enterprise development builds, stored as dev_<full-archive-version> with their revision, separately from releases. Use "tt binary search tarantool" or "tt binary search tarantool-ee" to list versions.

Omitting the version selects the latest Community release. Git commits, master, and pull requests also select Community Edition. Use pr/<number> for a pull request.

With --local-repo <dir>, <dir>/tarantool must be a local Git clone of the Tarantool source repository. With an Enterprise version, 3ee or gc64-3.8.0-0-r94, --local-dir <dir> installs it from the SDK archives in <dir>.

Git commits, master, and pull requests are built from source automatically. The --local-repo, --dynamic, and --use-docker options also select source builds.

Use --from-build <dir> to link an existing Community or Enterprise build into the selected scope without copying or rebuilding it. Use --include-dir to select the headers directory. --from-build accepts no version argument.

Usage

tt binary install tarantool [version|commit|pull-request] [flags]

Flags

  • --credentials-file string - File containing customer-zone login and password on separate lines
  • --dev - Install a development build (Enterprise Edition only)
  • --dynamic - Build Tarantool with dynamic linking
  • --from-build string - Link Tarantool from an existing build directory
  • --include-dir string - Path to the Tarantool headers directory (requires --from-build)
  • --local-dir string - Directory with Tarantool Enterprise SDK archives (tarantool-enterprise-sdk-*.tar.gz)
  • --local-repo string - Directory containing the Tarantool Git source repository in tarantool/
  • --source-build - Always build Tarantool Community releases from source
  • --use-docker - Build Tarantool in an Ubuntu Docker container

Global flags

  • -f, --force - Skip dependency checks, and the question of an unknown OS
  • --no-clean - Keep temporary files
  • --reinstall - Reinstall an existing version
  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands
  • -y, --yes - Answer yes to the questions of the installation

Examples

# Build and install Tarantool from the local repository.
$ tt binary install tarantool --local-repo ./distfiles

# Link an existing Tarantool build into the project scope.
$ tt binary install tarantool \
    --from-build ~/src/tarantool/build

# Link a build with custom headers into the user scope.
$ tt binary install tarantool --scope user \
    --from-build ~/src/tarantool/build \
    --include-dir ~/src/tarantool/include

# Build Tarantool with two parallel jobs.
$ MAKEFLAGS="-j2" tt binary install tarantool 3.4.0 --source-build

# Install the latest Enterprise release in minor version 3.8.
$ tt binary install tarantool 3.8ee

tt binary install tarantool-sdk

Install Tarantool Enterprise, tt Enterprise, and TCM together with headers.

Omitting the version selects the latest stable gc64 build. Specify X, X.Y, or X.Y.Z to select the latest matching stable gc64 build, or a complete version name to select an exact build, including nogc64 or RC. Use --local-dir <dir> to install an SDK archive from a local directory.

Components have separate sdk-<bundle-version> identities. Use "tt binary switch sdk" to select the entire SDK, or switch individual products independently. With --dev, the SDK uses dev_<bundle-version> and its components use sdk-dev_<bundle-version>, including the full archive revision, separately from releases. For project installations, run "source .env/activate.sh" in the project directory to activate the installed binaries.

Usage

tt binary install tarantool-sdk [version] [flags]

Aliases: sdk, SDK.

Flags

  • --credentials-file string - File containing customer-zone login and password on separate lines
  • --dev - Install a development build
  • --local-dir string - Directory with Tarantool Enterprise SDK archives (tarantool-enterprise-sdk-*.tar.gz)

Global flags

  • -f, --force - Skip dependency checks, and the question of an unknown OS
  • --no-clean - Keep temporary files
  • --reinstall - Reinstall an existing version
  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands
  • -y, --yes - Answer yes to the questions of the installation

Examples

# Install the latest stable SDK for this project.
$ tt binary install tarantool-sdk

# Install SDK 3.7.1 from a local directory in the user scope.
$ tt binary install sdk 3.7.1 --local-dir ./bundles --scope user

tt binary install tcm

Install tcm from its standalone archive.

Omitting the version selects the latest stable build. Specify X, X.Y, or X.Y.Z to select the latest matching stable build, or a complete version name to select an exact build, including RC. Partial names with prerelease or commit suffixes are not supported. Use "tt binary search tcm" to list available versions.

Use --dev for development builds, stored separately as dev_<full-archive-version>.

With --local-dir <dir>, the directory must contain tcm-*.tar.gz archives. The archive contains the tcm executable directly at its root.

Usage

tt binary install tcm [version] [flags]

Flags

  • --credentials-file string - File containing customer-zone login and password on separate lines
  • --dev - Install a development build
  • --local-dir string - Directory containing tcm standalone archives

Global flags

  • -f, --force - Skip dependency checks, and the question of an unknown OS
  • --no-clean - Keep temporary files
  • --reinstall - Reinstall an existing version
  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands
  • -y, --yes - Answer yes to the questions of the installation

tt binary install tt

Install tt Community or Enterprise Edition.

Install prebuilt Community binaries from GitHub Releases: tt 3 is published for Linux amd64/arm64 and macOS arm64 (tt 2 for macOS amd64 instead of arm64). On other platforms, use --source-build to compile tt from source. Releases without prebuilt archives are built from source automatically. Use --source-build to always compile Community releases from source.

Bare versions select Community Edition: 3, 3.0, or 3.0.0. Append ce or ee to select an edition explicitly: 3ce, 3.0ce, 3.0.0ce, 2ee, 2.15ee, or 2.15.0ee. Omitting the version selects the latest Community release of tt 3: the newest stable one, or the newest pre-release while tt 3 has none; tt 2 is installed only by its version. Git commits, master, and pull requests also select Community Edition. Use pr/<number> for a pull request. Git commits, master, pull requests, and --local-repo select source builds automatically.

With --local-repo <dir>, <dir>/tt must be a local Git clone of the tt source repository. With an ee version, --local-dir <dir> installs Enterprise Edition from the standalone tt-ee-*.tar.gz archives in <dir>: 2.15ee --local-dir <dir>. Enterprise search and installation are available only on Linux amd64. Use "tt binary search tt" or "tt binary search tt-ee" to list available versions.

Usage

tt binary install tt [version|commit|pull-request] [flags]

Flags

  • --credentials-file string - File containing customer-zone login and password on separate lines
  • --local-dir string - Directory containing tt-ee standalone archives
  • --local-repo string - Directory containing the tt Git source repository in tt/
  • --source-build - Always build tt Community releases from source

Global flags

  • -f, --force - Skip dependency checks, and the question of an unknown OS
  • --no-clean - Keep temporary files
  • --reinstall - Reinstall an existing version
  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands
  • -y, --yes - Answer yes to the questions of the installation

Examples

# Install the latest tt release for the current user.
$ tt binary install tt --scope user

# Build tt from a pull request for this project.
$ tt binary install tt pr/534

# Build tt from a local source repository.
$ tt binary install tt master --local-repo ./distfiles

# Install the latest tt Enterprise release in minor version 2.15.
$ tt binary install tt 2.15ee

tt binary list

List installed versions and active binaries in the selected scope. The project scope is the .tarantool of the project the current directory is in, found as "tt binary --help" says, even from its subdirectories; outside a project, the .tarantool of the current directory.

Each line names the product and the version; the active version is marked [active]. A local build linked with --from-build is listed by its path. Use -o json or -o yaml for the same data in a machine format.

Usage

tt binary list [flags]

Flags

  • -o, --format string - output format: table, json or yaml (default table)

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

Search available program versions and mark installations in the selected scope. Only that scope supplies [installed] and [active] labels.

For tt and Tarantool, use --local-repo <dir> with Git source repositories in <dir>/tt or <dir>/tarantool. For Enterprise products and TCM, use --local-dir <dir> with SDK, tt-ee, or TCM .tar.gz archives directly in that directory.

Usage

tt binary search
tt binary search [flags] <command> [command flags]

Commands

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

Examples

# Search Tarantool Enterprise Edition releases.
$ tt binary search tarantool-ee

# Search Tarantool Enterprise Edition 3.0 debug builds.
$ tt binary search tarantool-ee --debug --version 3.0

# Search Tarantool Cluster Manager 1.3 releases.
$ tt binary search tcm --version 1.3

# Search local sources and mark versions installed for the current user.
$ tt binary search tt --scope user --local-repo ./sources

tt binary search tarantool

Search available Tarantool Community Edition versions.

Available Tarantool Community Edition releases start with version 3.0. The X.Y.Z-entrypoint tags of the repository mark where a version starts and are no releases: they are left out unless --all is given, and installing one builds it from source.

The versions are the Git tags of the repository. Without git on PATH, only the releases with a prebuilt build for this host are listed: those of rws.tarantool.org.

With --local-repo <dir>, <dir>/tarantool must be a local Git clone of the Tarantool source repository. Versions are read from its Git tags.

Usage

tt binary search tarantool [flags]

Flags

  • --all - Also list the X.Y.Z-entrypoint development tags
  • --local-repo string - Directory containing the Tarantool Git source repository in tarantool/

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary search tarantool-ee

Search available tarantool-ee versions from SDK archives. Installed and active labels refer to the requested product in the selected scope.

With --local-dir <dir>, the directory must contain Tarantool Enterprise SDK archives named tarantool-enterprise-sdk-*.tar.gz. Archives are read directly from that directory.

Usage

tt binary search tarantool-ee [flags]

Flags

  • --credentials-file string - File containing customer-zone login and password on separate lines
  • --debug - Search debug builds
  • --dev - Search development builds
  • --local-dir string - Directory with Tarantool Enterprise SDK archives (tarantool-enterprise-sdk-*.tar.gz)
  • --version string - Filter by release version

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary search tarantool-sdk

Search available tarantool-sdk versions from SDK archives. Installed and active labels refer to the requested product in the selected scope.

With --local-dir <dir>, the directory must contain Tarantool Enterprise SDK archives named tarantool-enterprise-sdk-*.tar.gz. Archives are read directly from that directory.

Usage

tt binary search tarantool-sdk [flags]

Aliases: sdk, SDK.

Flags

  • --credentials-file string - File containing customer-zone login and password on separate lines
  • --debug - Search debug builds
  • --dev - Search development builds
  • --local-dir string - Directory with Tarantool Enterprise SDK archives (tarantool-enterprise-sdk-*.tar.gz)
  • --version string - Filter by release version

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary search tcm

Search available tcm versions from standalone archives.

With --local-dir <dir>, the directory must contain tcm-*.tar.gz archives. Archives are read directly from that directory.

Usage

tt binary search tcm [flags]

Flags

  • --credentials-file string - File containing customer-zone login and password on separate lines
  • --dev - Search development builds
  • --local-dir string - Directory containing tcm standalone archives
  • --version string - Filter by release version

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary search tt

Search available tt versions.

The versions are the Git tags of the repository. Without git on PATH, only the releases with a prebuilt build for this host are listed: those of tt on GitHub, which the GitHub API lists (GITHUB_TOKEN lifts its rate limit).

With --local-repo <dir>, <dir>/tt must be a local Git clone of the tt source repository. Versions are read from its Git tags.

Usage

tt binary search tt [flags]

Flags

  • --local-repo string - Directory containing the tt Git source repository in tt/

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary search tt-ee

Search available tt-ee versions from standalone archives.

With --local-dir <dir>, the directory must contain tt-ee-*.tar.gz archives. Archives are read directly from that directory.

tt-ee search and installation are available only on Linux amd64.

Usage

tt binary search tt-ee [flags]

Flags

  • --credentials-file string - File containing customer-zone login and password on separate lines
  • --local-dir string - Directory containing tt-ee standalone archives
  • --version string - Filter by release version

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary switch

Switch to an installed version in the selected scope. Without arguments, choose the program and version interactively. With only a program, choose its version; for tarantool and tt the menu lists the installed versions of both editions, Enterprise ones with the ee suffix. The menus need a terminal: off one, a missing version is an error that lists the installed versions. CE and EE share the active Tarantool binary and headers. tt and tt-ee share the active tt executable.

Bare Tarantool and tt versions select CE; append ce or ee to choose an edition explicitly. Tarantool Enterprise build names and sdk-<bundle-version> select EE.

Switching tarantool-sdk (also sdk and SDK) selects all of its components and headers together. Use sdk-<bundle-version> to select an individual SDK component.

X, X.Y, or X.Y.Z must match a single installed version in the selected scope: "tt binary switch tarantool 3.9" selects the 3.9.0 installed. If multiple builds match, the command reports their full names and requires an unambiguous choice before changing the active version. Use a full installed version name to select a specific build.

Usage

tt binary switch [program] [version]

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

Examples

# Choose a program and version interactively.
$ tt binary switch --scope project

# Choose a Tarantool version interactively.
$ tt binary switch tarantool --scope project

# Switch to a specific Tarantool version.
$ tt binary switch tarantool 3.0.0 --scope project

tt binary uninstall

Uninstall a program version from the selected scope.

Without a version, remove the only installed version of that product. For Tarantool, an active local build is unlinked without deleting its source. Removing an active version selects the latest eligible remaining version within the same scope. Parent directories and other scopes are not searched.

Usage

tt binary uninstall
tt binary uninstall [flags] <command> [command flags]

Commands

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

Examples

# Uninstall a Tarantool version.
$ tt binary uninstall tarantool 3.0.0 --scope project

tt binary uninstall tarantool

Uninstall a Tarantool version. Bare versions select Community Edition. Append ce or ee to choose an edition explicitly, or use an Enterprise build name such as gc64-3.8.0-0-r94. Without a version, unlink the active local build or uninstall the only installed version.

Usage

tt binary uninstall tarantool [version]

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary uninstall tarantool-sdk

Remove all components of the selected SDK version in the selected scope. X.Y.Z must match exactly one installed SDK; a full version selects an exact build. Without a version, uninstall the only installed SDK.

Usage

tt binary uninstall tarantool-sdk [version]

Aliases: sdk, SDK.

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary uninstall tcm

Uninstall a tcm version in the selected scope.

Specify X.Y.Z to select a single matching installed version, or use the full installed version name. If multiple builds match, the command reports their full names and requires an unambiguous choice before removing anything. Without a version, remove the only installed version.

Usage

tt binary uninstall tcm [version]

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary uninstall tt

Uninstall a tt version. Bare versions select Community Edition. Append ce or ee to select an edition explicitly, such as 2.15.0ce or 2.15.0ee. Without a version, uninstall the only installed Community version.

Usage

tt binary uninstall tt [version]

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

tt binary workspace

Write a Go workspace, go.work, to develop the local tt modules of the distribution tt.manifest.toml describes together with a local checkout of its core: go test, go build and gopls in a module then build it on the SDK of the checkout, whatever version of the SDK its go.mod requires - a commit that is not pushed yet as well.

The core is [core].path of the manifest, or --core DIR (or TT_DIST_CORE), as tt binary build tt takes it; a core given by a version is refused, as the module cache it comes from has no change of yours. The workspace uses every module of [dependencies] given by a path, and replaces with a directory, whatever their version:

- the core and every Go module of its repository its go.mod replaces with
  a directory of its own (sdk/..., modules/...);
- every Go module under sdk/ of the core, so that a new SDK module is in
  the workspace at once;
- every module [replace] replaces with a directory; a replacement with a
  module version is left out, with a warning.

The go directive is the newest of the go.mod files of them all.

The go command looks for go.work from the current directory up, so a go.work is written beside the manifest for the modules in the manifest's directory, and in the directory of every other module: one file for a module whose repository has its manifest at the root (path = "."), or a distribution with its modules under it, and one in each module that lives beside its distribution (path = "../tt-foo"). Each file uses every local module of the distribution. The paths in it are relative to it.

A go.work tt writes starts with a comment that says so. tt rewrites such a file and refuses to overwrite any other unless --force; --remove deletes the files tt wrote, with their go.work.sum, and refuses, deleting nothing, when one of them is not tt's. --remove needs no local core: the manifest may name a version of the core again by then. The paths of the files are printed to stdout; --dry-run prints them with what would be written, and changes nothing.

tt binary build tt does not read go.work: it builds with GOWORK=off on the core of the manifest, and leaves go.work and go.work.sum out of the content hash of a local module. go mod tidy does not read it either. Keep the files out of git: they name directories of your machine.

Usage

tt binary workspace [flags]

Flags

  • --core string - take this local checkout of the core instead of [core].path (env TT_DIST_CORE)
  • -C, --directory string - work on the project in DIR itself, not on the one the current directory is in
  • --dry-run - print what would be written or removed, and change nothing
  • -f, --force - overwrite a go.work tt did not write
  • --manifest string - path to the manifest (default: tt.manifest.toml in the project directory)
  • --remove - delete the go.work files tt wrote, and their go.work.sum

Global flags

  • --scope string - Scope: project, user or system (default project)
  • -V, --verbose - Show diagnostic output and build commands

Examples

# Write go.work for the modules of ./tt.manifest.toml on its [core].path.
$ tt binary workspace

# The same on another checkout of the core, without editing the manifest.
$ tt binary workspace --core ../tt

# Show what would be written.
$ tt binary workspace --dry-run

# Delete the files when the core change is pushed.
$ tt binary workspace --remove